minor: removed voids

panda/src/audio/audio_gui_functor.cxx

@@ -24,7 +24,7 @@ AudioGuiFunctor::AudioGuiFunctor(AudioSound* sound,
                                  GuiBehavior::BehaviorFunctor* prev)
   : GuiBehavior::BehaviorFunctor(), _prev(prev), _sound(sound) {}
 
-AudioGuiFunctor::~AudioGuiFunctor(void) {
+AudioGuiFunctor::~AudioGuiFunctor() {
   _prev.clear();
 }
 

panda/src/audio/audio_gui_functor.h

@@ -27,28 +27,28 @@ protected:
   PT(GuiBehavior::BehaviorFunctor) _prev;
   PT(AudioSound) _sound;
 public:
-  virtual ~AudioGuiFunctor(void);
+  virtual ~AudioGuiFunctor();
   virtual void doit(GuiBehavior*);
 PUBLISHED:
   AudioGuiFunctor(AudioSound* = (AudioSound*)0L,
                   GuiBehavior::BehaviorFunctor* =
                   (GuiBehavior::BehaviorFunctor*)0L);
-  INLINE AudioSound* get_sound(void) const { return _sound; }
-  INLINE GuiBehavior::BehaviorFunctor* get_prev(void) const { return _prev; }
+  INLINE AudioSound* get_sound() const { return _sound; }
+  INLINE GuiBehavior::BehaviorFunctor* get_prev() const { return _prev; }
 public:
   // type interface
-  static TypeHandle get_class_type(void) {
+  static TypeHandle get_class_type() {
     return _type_handle;
   }
-  static void init_type(void) {
+  static void init_type() {
     GuiBehavior::BehaviorFunctor::init_type();
     register_type(_type_handle, "AudioGuiFunctor",
                   GuiBehavior::BehaviorFunctor::get_class_type());
   }
-  virtual TypeHandle get_type(void) const {
+  virtual TypeHandle get_type() const {
     return get_class_type();
   }
-  virtual TypeHandle force_init_type(void) {
+  virtual TypeHandle force_init_type() {
     init_type();
     return get_class_type();
   }

panda/src/audio/audio_linux_traits.I

@@ -20,15 +20,15 @@ INLINE LinuxSample::LinuxSample(byte* b, unsigned long s)
   : AudioTraits::SoundClass(), _data(b), _size(s) {
 }
 
-INLINE byte* LinuxSample::get_data(void) const {
+INLINE byte* LinuxSample::get_data() const {
   return _data;
 }
 
-INLINE unsigned long LinuxSample::get_size(void) const {
+INLINE unsigned long LinuxSample::get_size() const {
   return _size;
 }
 
-INLINE LinuxMusic::LinuxMusic(void) : AudioTraits::SoundClass() {
+INLINE LinuxMusic::LinuxMusic() : AudioTraits::SoundClass() {
 }
 
 INLINE LinuxSamplePlaying::LinuxSamplePlaying(AudioTraits::SoundClass* s)
@@ -37,7 +37,7 @@ INLINE LinuxSamplePlaying::LinuxSamplePlaying(AudioTraits::SoundClass* s)
   _buff = new Buffer(smpl->get_data(), smpl->get_size());
 }
 
-INLINE Buffer* LinuxSamplePlaying::get_data(void) {
+INLINE Buffer* LinuxSamplePlaying::get_data() {
   return _buff;
 }
 
@@ -45,10 +45,10 @@ INLINE LinuxMusicPlaying::LinuxMusicPlaying(AudioTraits::SoundClass* s)
   : AudioTraits::PlayingClass(s) {
 }
 
-INLINE LinuxSamplePlayer::LinuxSamplePlayer(void)
+INLINE LinuxSamplePlayer::LinuxSamplePlayer()
   : AudioTraits::PlayerClass() {
 }
 
-INLINE LinuxMusicPlayer::LinuxMusicPlayer(void)
+INLINE LinuxMusicPlayer::LinuxMusicPlayer()
   : AudioTraits::PlayerClass() {
 }

panda/src/audio/audio_linux_traits.cxx

@@ -49,7 +49,7 @@ static int sample_size = sizeof(short);
 
 BufferSet buffers;
 
-static void swap_buffers(void) {
+static void swap_buffers() {
   byte *tmp = current_buffer;
   current_buffer = back_buffer;
   back_buffer = tmp;
@@ -149,7 +149,7 @@ static void mix_buffer(byte* buf) {
   }
 }
 
-static void update_linux(void) {
+static void update_linux() {
   if (buffers.empty())
     return;
   if (!audio_is_active)
@@ -230,13 +230,13 @@ static void* internal_update(void*) {
   return (void*)0L;
 }
 
-static void shutdown_linux(void) {
+static void shutdown_linux() {
   stop_mixing = true;
   while (stop_mixing);
   audio_cat->debug() << "I believe the internal thread has exited" << endl;
 }
 
-static void initialize(void) {
+static void initialize() {
   if (have_initialized)
     return;
   if (!audio_is_active)
@@ -268,22 +268,22 @@ static void initialize(void) {
   have_initialized = true;
 }
 
-LinuxSample::~LinuxSample(void) {
+LinuxSample::~LinuxSample() {
 }
 
-float LinuxSample::length(void) const {
+float LinuxSample::length() const {
   return _size / (audio_mix_freq * sample_size * 2.);
 }
 
-AudioTraits::PlayingClass* LinuxSample::get_state(void) const {
+AudioTraits::PlayingClass* LinuxSample::get_state() const {
   return new LinuxSamplePlaying((LinuxSample*)this);
 }
 
-AudioTraits::PlayerClass* LinuxSample::get_player(void) const {
+AudioTraits::PlayerClass* LinuxSample::get_player() const {
   return LinuxSamplePlayer::get_instance();
 }
 
-AudioTraits::DeletePlayingFunc* LinuxSample::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* LinuxSample::get_delstate() const {
   return LinuxSamplePlaying::destroy;
 }
 
@@ -292,29 +292,29 @@ LinuxSample* LinuxSample::load_raw(byte* data, unsigned long size) {
   return ret;
 }
 
-LinuxMusic::~LinuxMusic(void) {
+LinuxMusic::~LinuxMusic() {
 }
 
-float LinuxMusic::length(void) const {
+float LinuxMusic::length() const {
   return -1.;
 }
 
-AudioTraits::PlayingClass* LinuxMusic::get_state(void) const {
+AudioTraits::PlayingClass* LinuxMusic::get_state() const {
   return new LinuxMusicPlaying((LinuxMusic*)this);
 }
 
-AudioTraits::PlayerClass* LinuxMusic::get_player(void) const {
+AudioTraits::PlayerClass* LinuxMusic::get_player() const {
   return LinuxMusicPlayer::get_instance();
 }
 
-AudioTraits::DeletePlayingFunc* LinuxMusic::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* LinuxMusic::get_delstate() const {
   return LinuxMusicPlaying::destroy;
 }
 
-LinuxSamplePlaying::~LinuxSamplePlaying(void) {
+LinuxSamplePlaying::~LinuxSamplePlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus LinuxSamplePlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus LinuxSamplePlaying::status() {
   BufferSet::iterator i = buffers.find(_buff);
   if (i != buffers.end())
     return AudioTraits::PlayingClass::PLAYING;
@@ -325,10 +325,10 @@ void LinuxSamplePlaying::destroy(AudioTraits::PlayingClass* state) {
   delete state;
 }
 
-LinuxMusicPlaying::~LinuxMusicPlaying(void) {
+LinuxMusicPlaying::~LinuxMusicPlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus LinuxMusicPlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus LinuxMusicPlaying::status() {
   return AudioTraits::PlayingClass::BAD;
 }
 
@@ -339,7 +339,7 @@ void LinuxMusicPlaying::destroy(AudioTraits::PlayingClass* state) {
 LinuxSamplePlayer* LinuxSamplePlayer::_global_instance =
    (LinuxSamplePlayer*)0L;
 
-LinuxSamplePlayer::~LinuxSamplePlayer(void) {
+LinuxSamplePlayer::~LinuxSamplePlayer() {
 }
 
 void LinuxSamplePlayer::play_sound(AudioTraits::SoundClass*,
@@ -377,7 +377,7 @@ bool LinuxSamplePlayer::adjust_volume(AudioTraits::PlayingClass*) {
   return false;
 }
 
-LinuxSamplePlayer* LinuxSamplePlayer::get_instance(void) {
+LinuxSamplePlayer* LinuxSamplePlayer::get_instance() {
   if (_global_instance == (LinuxSamplePlayer*)0L)
     _global_instance = new LinuxSamplePlayer();
   return _global_instance;
@@ -386,7 +386,7 @@ LinuxSamplePlayer* LinuxSamplePlayer::get_instance(void) {
 LinuxMusicPlayer* LinuxMusicPlayer::_global_instance =
    (LinuxMusicPlayer*)0L;
 
-LinuxMusicPlayer::~LinuxMusicPlayer(void) {
+LinuxMusicPlayer::~LinuxMusicPlayer() {
 }
 
 void LinuxMusicPlayer::play_sound(AudioTraits::SoundClass*,
@@ -407,7 +407,7 @@ bool LinuxMusicPlayer::adjust_volume(AudioTraits::PlayingClass*) {
   return false;
 }
 
-LinuxMusicPlayer* LinuxMusicPlayer::get_instance(void) {
+LinuxMusicPlayer* LinuxMusicPlayer::get_instance() {
   if (_global_instance == (LinuxMusicPlayer*)0L)
     _global_instance = new LinuxMusicPlayer();
   return _global_instance;

panda/src/audio/audio_linux_traits.h

@@ -58,10 +58,10 @@ public:
     }
     return buf;
   }
-  INLINE bool is_done(void) const {
+  INLINE bool is_done() const {
     return _done;
   }
-  INLINE unsigned long get_size(void) const {
+  INLINE unsigned long get_size() const {
     return _size;
   }
   INLINE void reset(unsigned long p = 0) {
@@ -78,56 +78,56 @@ private:
   unsigned long _size;
 public:
   INLINE LinuxSample(byte*, unsigned long);
-  virtual ~LinuxSample(void);
+  virtual ~LinuxSample();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 public:
   // used by the loader
   static LinuxSample* load_raw(byte*, unsigned long);
   // used by the players
-  INLINE byte* get_data(void) const;
-  INLINE unsigned long get_size(void) const;
+  INLINE byte* get_data() const;
+  INLINE unsigned long get_size() const;
 };
 
 class EXPCL_PANDA LinuxMusic : public AudioTraits::SoundClass {
 public:
-  INLINE LinuxMusic(void);
-  virtual ~LinuxMusic(void);
+  INLINE LinuxMusic();
+  virtual ~LinuxMusic();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 };
 
 class EXPCL_PANDA LinuxSamplePlaying : public AudioTraits::PlayingClass {
   Buffer* _buff;
 public:
   INLINE LinuxSamplePlaying(AudioTraits::SoundClass*);
-  virtual ~LinuxSamplePlaying(void);
+  virtual ~LinuxSamplePlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
 public:
-  INLINE Buffer* get_data(void);
+  INLINE Buffer* get_data();
   static void destroy(AudioTraits::PlayingClass*);
 };
 
 class EXPCL_PANDA LinuxMusicPlaying : public AudioTraits::PlayingClass {
 public:
   INLINE LinuxMusicPlaying(AudioTraits::SoundClass*);
-  virtual ~LinuxMusicPlaying(void);
+  virtual ~LinuxMusicPlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
 };
 
 class EXPCL_PANDA LinuxSamplePlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE LinuxSamplePlayer(void);
-  virtual ~LinuxSamplePlayer(void);
+  INLINE LinuxSamplePlayer();
+  virtual ~LinuxSamplePlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -137,15 +137,15 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static LinuxSamplePlayer* get_instance(void);
+  static LinuxSamplePlayer* get_instance();
 private:
   static LinuxSamplePlayer* _global_instance;
 };
 
 class EXPCL_PANDA LinuxMusicPlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE LinuxMusicPlayer(void);
-  virtual ~LinuxMusicPlayer(void);
+  INLINE LinuxMusicPlayer();
+  virtual ~LinuxMusicPlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -155,7 +155,7 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static LinuxMusicPlayer* get_instance(void);
+  static LinuxMusicPlayer* get_instance();
 private:
   static LinuxMusicPlayer* _global_instance;
 };

panda/src/audio/audio_manager.I

@@ -31,7 +31,7 @@ INLINE void AudioManager::play(AudioSound* sound, float start_time) {
 //       Access: Public, Static
 //  Description: make sure buffers are full
 ////////////////////////////////////////////////////////////////////
-INLINE void AudioManager::update(void) {
+INLINE void AudioManager::update() {
   if (!audio_is_active)
     return;
   {
@@ -48,7 +48,7 @@ INLINE void AudioManager::update(void) {
 //       Access: Public, Static
 //  Description: spawn a thread to call update
 ////////////////////////////////////////////////////////////////////
-INLINE void AudioManager::spawn_update(void) {
+INLINE void AudioManager::spawn_update() {
   if (audio_is_active)
     get_ptr()->ns_spawn_update();
 }
@@ -58,7 +58,7 @@ INLINE void AudioManager::spawn_update(void) {
 //       Access: Public, Static
 //  Description: kill any internal threads, free any internal data
 ////////////////////////////////////////////////////////////////////
-INLINE void AudioManager::shutdown(void) {
+INLINE void AudioManager::shutdown() {
   get_ptr()->ns_shutdown();
 }
 
@@ -108,7 +108,7 @@ INLINE bool AudioManager::get_loop(AudioSound* sound) {
 //               directly; there's only supposed to be one AudioManager
 //               in the universe and it constructs itself.
 ////////////////////////////////////////////////////////////////////
-INLINE AudioManager::AudioManager(void) {
+INLINE AudioManager::AudioManager() {
   _sfx_active = _hard_sfx_active = audio_sfx_active;
   _music_active = _hard_music_active = audio_music_active;
   _master_sfx_volume = audio_master_sfx_volume;
@@ -141,7 +141,7 @@ INLINE void AudioManager::set_master_music_volume(float v) {
 //       Access: Public, Static
 //  Description: return the overall volume of SFX
 ////////////////////////////////////////////////////////////////////
-INLINE float AudioManager::get_master_sfx_volume(void) {
+INLINE float AudioManager::get_master_sfx_volume() {
   get_ptr();
   return AudioManager::_master_sfx_volume;
 }
@@ -151,7 +151,7 @@ INLINE float AudioManager::get_master_sfx_volume(void) {
 //       Access: Public, Static
 //  Description: return the overall volume of music
 ////////////////////////////////////////////////////////////////////
-INLINE float AudioManager::get_master_music_volume(void) {
+INLINE float AudioManager::get_master_music_volume() {
   get_ptr();
   return AudioManager::_master_music_volume;
 }
@@ -171,7 +171,7 @@ INLINE void AudioManager::set_all_sound_active(bool f) {
 //       Access: Public, Static
 //  Description: turn on/off all audio
 ////////////////////////////////////////////////////////////////////
-INLINE bool AudioManager::get_all_sound_active(void) {
+INLINE bool AudioManager::get_all_sound_active() {
   get_ptr();
   return audio_is_active;
 }
@@ -217,7 +217,7 @@ INLINE void AudioManager::set_music_active(bool f) {
 //       Access: Public, Static
 //  Description: return the state of SFX playing
 ////////////////////////////////////////////////////////////////////
-INLINE bool AudioManager::get_sfx_active(void) {
+INLINE bool AudioManager::get_sfx_active() {
   get_ptr();
   return (AudioManager::_sfx_active && audio_is_active);
 }
@@ -227,7 +227,7 @@ INLINE bool AudioManager::get_sfx_active(void) {
 //       Access: Public, Static
 //  Description: return the state of music playing
 ////////////////////////////////////////////////////////////////////
-INLINE bool AudioManager::get_music_active(void) {
+INLINE bool AudioManager::get_music_active() {
   get_ptr();
   return (AudioManager::_music_active && audio_is_active);
 }

panda/src/audio/audio_manager.cxx

@@ -42,7 +42,7 @@ float AudioManager::_master_music_volume = 0.;
 //       Access: Public
 //  Description: delete the AudioManager singleton
 ////////////////////////////////////////////////////////////////////
-AudioManager::~AudioManager(void) {
+AudioManager::~AudioManager() {
   shutdown();
   _global_ptr = (AudioManager*)0L;
 }
@@ -66,7 +66,7 @@ void AudioManager::set_update_func(AudioManager::UpdateFunc* func) {
 //  Description: make a copy of the loopset to use for the rest of
 //               update
 ////////////////////////////////////////////////////////////////////
-void AudioManager::copy_loopset(void) {
+void AudioManager::copy_loopset() {
   if (_loopcopy == (LoopSet*)0L)
     _loopcopy = new LoopSet;
   if (_loopset != (LoopSet*)0L)
@@ -78,7 +78,7 @@ void AudioManager::copy_loopset(void) {
 //       Access: Public, Static
 //  Description: do generic update stuff
 ////////////////////////////////////////////////////////////////////
-void AudioManager::ns_update(void) {
+void AudioManager::ns_update() {
   // handle looping
   if (_loopcopy != (LoopSet*)0L)
     for (LoopSet::iterator i=_loopcopy->begin(); i!=_loopcopy->end(); ++i) {
@@ -122,7 +122,7 @@ void AudioManager::set_shutdown_func(AudioManager::ShutdownFunc* func) {
 //  Description: Initializes and/or returns the global pointer to the
 //               one AudioManager object in the system.
 ////////////////////////////////////////////////////////////////////
-AudioManager* AudioManager::get_ptr(void) {
+AudioManager* AudioManager::get_ptr() {
   if (_global_ptr == (AudioManager*)0L)
     _global_ptr = new AudioManager;
   return _global_ptr;
@@ -217,7 +217,7 @@ void AudioManager::ns_set_volume(AudioSound* sound, float v) {
 //       Access: Private
 //  Description: spawn a thread that calls update every so often
 ////////////////////////////////////////////////////////////////////
-void AudioManager::ns_spawn_update(void) {
+void AudioManager::ns_spawn_update() {
   if (_spawned == (thread*)0L) {
     if (_quit == (bool*)0L)
       _quit = new bool(false);
@@ -250,7 +250,7 @@ void AudioManager::ns_spawn_update(void) {
 //       Access: Private
 //  Description: non-static implementation of shutdown stuff
 ////////////////////////////////////////////////////////////////////
-void AudioManager::ns_shutdown(void) {
+void AudioManager::ns_shutdown() {
   if (_quit != (bool*)0L)
     *_quit = true;
   if (_shutdown_func != (ShutdownFunc*)0L)

panda/src/audio/audio_manager.h

@@ -29,23 +29,23 @@
 
 class EXPCL_PANDA AudioManager {
 private:
-  INLINE AudioManager(void);
+  INLINE AudioManager();
 
-  void copy_loopset(void);
+  void copy_loopset();
   void ns_play(AudioSound*, float);
   void ns_stop(AudioSound*);
   void ns_set_loop(AudioSound*, bool);
   bool ns_get_loop(AudioSound*);
   void ns_set_volume(AudioSound*, float);
-  void ns_spawn_update(void);
-  void ns_shutdown(void);
-  void ns_update(void);
+  void ns_spawn_update();
+  void ns_shutdown();
+  void ns_update();
 
-  static AudioManager* get_ptr(void);
+  static AudioManager* get_ptr();
   static void* spawned_update(void*);
 
-  typedef void UpdateFunc(void);
-  typedef void ShutdownFunc(void);
+  typedef void UpdateFunc();
+  typedef void ShutdownFunc();
   typedef pset<AudioSound*> LoopSet;
   static AudioManager* _global_ptr;
   static UpdateFunc* _update_func;
@@ -63,7 +63,7 @@ private:
   static float _master_music_volume;
   static bool _master_volume_change;
 public:
-  virtual ~AudioManager(void);
+  virtual ~AudioManager();
 
   static void set_update_func(UpdateFunc*);
   static void set_shutdown_func(ShutdownFunc*);
@@ -74,19 +74,19 @@ PUBLISHED:
   INLINE static void set_loop(AudioSound*, bool);
   INLINE static bool get_loop(AudioSound*);
   INLINE static void set_volume(AudioSound*, float);
-  INLINE static void update(void);
-  INLINE static void spawn_update(void);
-  INLINE static void shutdown(void);
+  INLINE static void update();
+  INLINE static void spawn_update();
+  INLINE static void shutdown();
   INLINE static void set_master_sfx_volume(float);
   INLINE static void set_master_music_volume(float);
-  INLINE static float get_master_sfx_volume(void);
-  INLINE static float get_master_music_volume(void);
+  INLINE static float get_master_sfx_volume();
+  INLINE static float get_master_music_volume();
   INLINE static void set_all_sound_active(bool);
-  INLINE static bool get_all_sound_active(void);
+  INLINE static bool get_all_sound_active();
   INLINE static void set_sfx_active(bool);
   INLINE static void set_music_active(bool);
-  INLINE static bool get_sfx_active(void);
-  INLINE static bool get_music_active(void);
+  INLINE static bool get_sfx_active();
+  INLINE static bool get_music_active();
 public:
   INLINE static void set_hard_sfx_active(bool);
   INLINE static void set_hard_music_active(bool);

panda/src/audio/audio_midi.cxx

@@ -234,7 +234,7 @@ AudioMidi::AudioMidi(Filename filename, int header_idx) {
 
 AudioMidi::AudioMidi(const AudioMidi& c) : _seq(c._seq) {}
 
-AudioMidi::~AudioMidi(void) {
+AudioMidi::~AudioMidi() {
 }
 
 AudioMidi& AudioMidi::operator=(const AudioMidi&) {

panda/src/audio/audio_midi.h

@@ -30,7 +30,7 @@ private:
 public:
   AudioMidi(Filename, int = 1);
   AudioMidi(const AudioMidi&);
-  ~AudioMidi(void);
+  ~AudioMidi();
 
   AudioMidi& operator=(const AudioMidi&);
   bool operator==(const AudioMidi&) const;

panda/src/audio/audio_mikmod_traits.cxx

@@ -28,11 +28,11 @@
 static bool have_initialized = false;
 static bool initialization_error = false;
 
-static void update_mikmod(void) {
+static void update_mikmod() {
   MikMod_Update();
 }
 
-static void initialize(void) {
+static void initialize() {
   if (have_initialized)
     return;
   if (initialization_error)
@@ -140,25 +140,25 @@ static void initialize(void) {
 MikModSample::MikModSample(SAMPLE* sample) : _sample(sample) {
 }
 
-MikModSample::~MikModSample(void) {
+MikModSample::~MikModSample() {
   Sample_Free(_sample);
 }
 
-float MikModSample::length(void) const {
+float MikModSample::length() const {
   float len = _sample->length;
   float speed = _sample->speed;
   return len / speed;
 }
 
-AudioTraits::PlayingClass* MikModSample::get_state(void) const {
+AudioTraits::PlayingClass* MikModSample::get_state() const {
   return new MikModSamplePlaying((MikModSample*)this);
 }
 
-AudioTraits::PlayerClass* MikModSample::get_player(void) const {
+AudioTraits::PlayerClass* MikModSample::get_player() const {
   return MikModSamplePlayer::get_instance();
 }
 
-AudioTraits::DeletePlayingFunc* MikModSample::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* MikModSample::get_delstate() const {
   return MikModSamplePlaying::destroy;
 }
 
@@ -173,40 +173,40 @@ MikModSample* MikModSample::load_wav(Filename filename) {
   return new MikModSample(sample);
 }
 
-SAMPLE* MikModSample::get_sample(void) {
+SAMPLE* MikModSample::get_sample() {
   return _sample;
 }
 
-int MikModSample::get_freq(void) {
+int MikModSample::get_freq() {
   return _sample->speed;
 }
 
-MikModMusic::MikModMusic(void) {
+MikModMusic::MikModMusic() {
 }
 
-MikModMusic::~MikModMusic(void) {
+MikModMusic::~MikModMusic() {
 }
 
-float MikModMusic::length(void) const {
+float MikModMusic::length() const {
   return -1.;
 }
 
-AudioTraits::PlayingClass* MikModMusic::get_state(void) const {
+AudioTraits::PlayingClass* MikModMusic::get_state() const {
   return new MikModMusicPlaying((MikModMusic*)this);
 }
 
-AudioTraits::PlayerClass* MikModMusic::get_player(void) const {
+AudioTraits::PlayerClass* MikModMusic::get_player() const {
   return MikModFmsynthPlayer::get_instance();
 }
 
-AudioTraits::DeletePlayingFunc* MikModMusic::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* MikModMusic::get_delstate() const {
   return MikModMusicPlaying::destroy;
 }
 
-MikModMidi::MikModMidi(void) {
+MikModMidi::MikModMidi() {
 }
 
-MikModMidi::~MikModMidi(void) {
+MikModMidi::~MikModMidi() {
 }
 
 MikModMidi* MikModMidi::load_midi(Filename) {
@@ -214,19 +214,19 @@ MikModMidi* MikModMidi::load_midi(Filename) {
   return new MikModMidi();
 }
 
-float MikModMidi::length(void) const {
+float MikModMidi::length() const {
   return -1.;
 }
 
-AudioTraits::PlayingClass* MikModMidi::get_state(void) const {
+AudioTraits::PlayingClass* MikModMidi::get_state() const {
   return new MikModMidiPlaying((MikModMidi*)this);
 }
 
-AudioTraits::PlayerClass* MikModMidi::get_player(void) const {
+AudioTraits::PlayerClass* MikModMidi::get_player() const {
   return MikModMidiPlayer::get_instance();
 }
 
-AudioTraits::DeletePlayingFunc* MikModMidi::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* MikModMidi::get_delstate() const {
   return MikModMidiPlaying::destroy;
 }
 
@@ -234,10 +234,10 @@ MikModSamplePlaying::MikModSamplePlaying(AudioTraits::SoundClass* s)
   : AudioTraits::PlayingClass(s) {
 }
 
-MikModSamplePlaying::~MikModSamplePlaying(void) {
+MikModSamplePlaying::~MikModSamplePlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus MikModSamplePlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus MikModSamplePlaying::status() {
   return AudioTraits::PlayingClass::BAD;
 }
 
@@ -245,7 +245,7 @@ void MikModSamplePlaying::set_voice(int v) {
   _voice = v;
 }
 
-int MikModSamplePlaying::get_voice(void) const {
+int MikModSamplePlaying::get_voice() const {
   return _voice;
 }
 
@@ -257,10 +257,10 @@ MikModMusicPlaying::MikModMusicPlaying(AudioTraits::SoundClass* s)
   : AudioTraits::PlayingClass(s) {
 }
 
-MikModMusicPlaying::~MikModMusicPlaying(void) {
+MikModMusicPlaying::~MikModMusicPlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus MikModMusicPlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus MikModMusicPlaying::status() {
   return AudioTraits::PlayingClass::BAD;
 }
 
@@ -272,10 +272,10 @@ MikModMidiPlaying::MikModMidiPlaying(AudioTraits::SoundClass* s)
   : AudioTraits::PlayingClass(s) {
 }
 
-MikModMidiPlaying::~MikModMidiPlaying(void) {
+MikModMidiPlaying::~MikModMidiPlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus MikModMidiPlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus MikModMidiPlaying::status() {
   return AudioTraits::PlayingClass::BAD;
 }
 
@@ -286,10 +286,10 @@ void MikModMidiPlaying::destroy(AudioTraits::PlayingClass* play) {
 MikModSamplePlayer* MikModSamplePlayer::_global_instance =
     (MikModSamplePlayer*)0L;
 
-MikModSamplePlayer::MikModSamplePlayer(void) : AudioTraits::PlayerClass() {
+MikModSamplePlayer::MikModSamplePlayer() : AudioTraits::PlayerClass() {
 }
 
-MikModSamplePlayer::~MikModSamplePlayer(void) {
+MikModSamplePlayer::~MikModSamplePlayer() {
 }
 
 void MikModSamplePlayer::play_sound(AudioTraits::SoundClass* sample,
@@ -344,7 +344,7 @@ bool MikModSamplePlayer::adjust_volume(AudioTraits::PlayingClass* state) {
   return false;
 }
 
-MikModSamplePlayer* MikModSamplePlayer::get_instance(void) {
+MikModSamplePlayer* MikModSamplePlayer::get_instance() {
   if (_global_instance == (MikModSamplePlayer*)0L)
     _global_instance = new MikModSamplePlayer();
   return _global_instance;
@@ -353,10 +353,10 @@ MikModSamplePlayer* MikModSamplePlayer::get_instance(void) {
 MikModFmsynthPlayer* MikModFmsynthPlayer::_global_instance =
   (MikModFmsynthPlayer*)0L;
 
-MikModFmsynthPlayer::MikModFmsynthPlayer(void) {
+MikModFmsynthPlayer::MikModFmsynthPlayer() {
 }
 
-MikModFmsynthPlayer::~MikModFmsynthPlayer(void) {
+MikModFmsynthPlayer::~MikModFmsynthPlayer() {
 }
 
 void MikModFmsynthPlayer::play_sound(AudioTraits::SoundClass*,
@@ -382,7 +382,7 @@ bool MikModFmsynthPlayer::adjust_volume(AudioTraits::PlayingClass*) {
   return false;
 }
 
-MikModFmsynthPlayer* MikModFmsynthPlayer::get_instance(void) {
+MikModFmsynthPlayer* MikModFmsynthPlayer::get_instance() {
   if (_global_instance == (MikModFmsynthPlayer*)0L)
     _global_instance = new MikModFmsynthPlayer();
   return _global_instance;
@@ -390,10 +390,10 @@ MikModFmsynthPlayer* MikModFmsynthPlayer::get_instance(void) {
 
 MikModMidiPlayer* MikModMidiPlayer::_global_instance = (MikModMidiPlayer*)0L;
 
-MikModMidiPlayer::MikModMidiPlayer(void) {
+MikModMidiPlayer::MikModMidiPlayer() {
 }
 
-MikModMidiPlayer::~MikModMidiPlayer(void) {
+MikModMidiPlayer::~MikModMidiPlayer() {
 }
 
 void MikModMidiPlayer::play_sound(AudioTraits::SoundClass*,
@@ -418,7 +418,7 @@ bool MikModMidiPlayer::adjust_volume(AudioTraits::PlayingClass*) {
   return false;
 }
 
-MikModMidiPlayer* MikModMidiPlayer::get_instance(void) {
+MikModMidiPlayer* MikModMidiPlayer::get_instance() {
   if (_global_instance == (MikModMidiPlayer*)0L)
     _global_instance = new MikModMidiPlayer();
   return _global_instance;

panda/src/audio/audio_mikmod_traits.h

@@ -35,43 +35,43 @@ private:
 
   MikModSample(SAMPLE*);
 public:
-  virtual ~MikModSample(void);
+  virtual ~MikModSample();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 public:
   // used by the readers
   static MikModSample* load_wav(Filename);
   // used by the players
-  virtual SAMPLE* get_sample(void);
-  virtual int get_freq(void);
+  virtual SAMPLE* get_sample();
+  virtual int get_freq();
 };
 
 class EXPCL_PANDA MikModMusic : public AudioTraits::SoundClass {
 private:
   MODULE* _music;
 public:
-  MikModMusic(void);
-  virtual ~MikModMusic(void);
+  MikModMusic();
+  virtual ~MikModMusic();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 };
 
 class EXPCL_PANDA MikModMidi : public AudioTraits::SoundClass {
 private:
 public:
-  MikModMidi(void);
-  virtual ~MikModMidi(void);
+  MikModMidi();
+  virtual ~MikModMidi();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 public:
   // used by the readers
   static MikModMidi* load_midi(Filename);
@@ -82,37 +82,37 @@ private:
   int _voice;
 public:
   MikModSamplePlaying(AudioTraits::SoundClass*);
-  ~MikModSamplePlaying(void);
+  ~MikModSamplePlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
 public:
   virtual void set_voice(int);
-  virtual int get_voice(void) const;
+  virtual int get_voice() const;
 };
 
 class EXPCL_PANDA MikModMusicPlaying : public AudioTraits::PlayingClass {
 public:
   MikModMusicPlaying(AudioTraits::SoundClass*);
-  ~MikModMusicPlaying(void);
+  ~MikModMusicPlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
 };
 
 class EXPCL_PANDA MikModMidiPlaying : public AudioTraits::PlayingClass {
 public:
   MikModMidiPlaying(AudioTraits::SoundClass*);
-  ~MikModMidiPlaying(void);
+  ~MikModMidiPlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
 };
 
 class EXPCL_PANDA MikModSamplePlayer : public AudioTraits::PlayerClass {
 public:
-  MikModSamplePlayer(void);
-  virtual ~MikModSamplePlayer(void);
+  MikModSamplePlayer();
+  virtual ~MikModSamplePlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -122,15 +122,15 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static MikModSamplePlayer* get_instance(void);
+  static MikModSamplePlayer* get_instance();
 private:
   static MikModSamplePlayer* _global_instance;
 };
 
 class EXPCL_PANDA MikModFmsynthPlayer : public AudioTraits::PlayerClass {
 public:
-  MikModFmsynthPlayer(void);
-  virtual ~MikModFmsynthPlayer(void);
+  MikModFmsynthPlayer();
+  virtual ~MikModFmsynthPlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -140,15 +140,15 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static MikModFmsynthPlayer* get_instance(void);
+  static MikModFmsynthPlayer* get_instance();
 private:
   static MikModFmsynthPlayer* _global_instance;
 };
 
 class EXPCL_PANDA MikModMidiPlayer : public AudioTraits::PlayerClass {
 public:
-  MikModMidiPlayer(void);
-  virtual ~MikModMidiPlayer(void);
+  MikModMidiPlayer();
+  virtual ~MikModMidiPlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -158,7 +158,7 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static MikModMidiPlayer* get_instance(void);
+  static MikModMidiPlayer* get_instance();
 private:
   static MikModMidiPlayer* _global_instance;
 };

panda/src/audio/audio_null_traits.I

@@ -16,12 +16,12 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-INLINE NullSound::NullSound(void) : AudioTraits::SoundClass() {
+INLINE NullSound::NullSound() : AudioTraits::SoundClass() {
 }
 
 INLINE NullPlaying::NullPlaying(AudioTraits::SoundClass* sound)
   : AudioTraits::PlayingClass(sound) {
 }
 
-INLINE NullPlayer::NullPlayer(void) : AudioTraits::PlayerClass() {
+INLINE NullPlayer::NullPlayer() : AudioTraits::PlayerClass() {
 }

panda/src/audio/audio_null_traits.cxx

@@ -25,44 +25,44 @@
 
 static bool have_initialized = false;
 
-static void update_null(void) {
+static void update_null() {
   if (audio_cat.is_debug())
     audio_cat->debug() << "Update in Null audio driver" << endl;
 }
 
-static void initialize(void) {
+static void initialize() {
   if (have_initialized)
     return;
   AudioManager::set_update_func(update_null);
   have_initialized = true;
 }
 
-NullSound::~NullSound(void) {
+NullSound::~NullSound() {
 }
 
-float NullSound::length(void) const {
+float NullSound::length() const {
   if (audio_cat.is_debug())
     audio_cat->debug() << "in sample length in Null audio driver" << endl;
   return -1.;
 }
 
-AudioTraits::PlayingClass* NullSound::get_state(void) const {
+AudioTraits::PlayingClass* NullSound::get_state() const {
   return new NullPlaying((NullSound*)this);
 }
 
-AudioTraits::PlayerClass* NullSound::get_player(void) const {
+AudioTraits::PlayerClass* NullSound::get_player() const {
   return new NullPlayer();
 }
 
 
-AudioTraits::DeletePlayingFunc* NullSound::get_delstate(void) const {
+AudioTraits::DeletePlayingFunc* NullSound::get_delstate() const {
   return NullPlaying::destroy;
 }
 
-NullPlaying::~NullPlaying(void) {
+NullPlaying::~NullPlaying() {
 }
 
-AudioTraits::PlayingClass::PlayingStatus NullPlaying::status(void) {
+AudioTraits::PlayingClass::PlayingStatus NullPlaying::status() {
   if (audio_cat.is_debug())
     audio_cat->debug() << "in playing status in Null audio driver" << endl;
   return BAD;
@@ -72,7 +72,7 @@ void NullPlaying::destroy(AudioTraits::PlayingClass* play) {
   delete play;
 }
 
-NullPlayer::~NullPlayer(void) {
+NullPlayer::~NullPlayer() {
 }
 
 void NullPlayer::play_sound(AudioTraits::SoundClass*,

panda/src/audio/audio_null_traits.h

@@ -28,28 +28,28 @@ class NullPlaying;
 
 class EXPCL_PANDA NullSound : public AudioTraits::SoundClass {
 public:
-  INLINE NullSound(void);
-  virtual ~NullSound(void);
+  INLINE NullSound();
+  virtual ~NullSound();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 };
 
 class EXPCL_PANDA NullPlaying : public AudioTraits::PlayingClass {
 public:
   INLINE NullPlaying(AudioTraits::SoundClass*);
-  virtual ~NullPlaying(void);
+  virtual ~NullPlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
 };
 
 class EXPCL_PANDA NullPlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE NullPlayer(void);
-  virtual ~NullPlayer(void);
+  INLINE NullPlayer();
+  virtual ~NullPlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);

panda/src/audio/audio_pool.I

@@ -79,7 +79,7 @@ INLINE void AudioPool::release_sound(AudioSound* sound) {
 //  Description: Releases all sounds in the pool and restores the
 //               pool to the empty state.
 ////////////////////////////////////////////////////////////////////
-INLINE void AudioPool::release_all_sounds(void) {
+INLINE void AudioPool::release_all_sounds() {
   get_ptr()->ns_release_all_sounds();
 }
 
@@ -90,7 +90,7 @@ INLINE void AudioPool::release_all_sounds(void) {
 //               directly; there's only supposed to be one AudioPool
 //               in the universe and it constructs itself.
 ////////////////////////////////////////////////////////////////////
-INLINE AudioPool::AudioPool(void) {}
+INLINE AudioPool::AudioPool() {}
 
 ////////////////////////////////////////////////////////////////////
 //     Function: AudioPool::get_num_loaded_sounds
@@ -98,7 +98,7 @@ INLINE AudioPool::AudioPool(void) {}
 //  Description: return the number of sounds the audiopool thinks
 //               are loaded at the moment
 ////////////////////////////////////////////////////////////////////
-INLINE int AudioPool::get_num_loaded_sounds(void) {
+INLINE int AudioPool::get_num_loaded_sounds() {
   return get_ptr()->_sounds.size();
 }
 

panda/src/audio/audio_pool.cxx

@@ -29,7 +29,7 @@ SoundLoaders* _sound_loaders = (SoundLoaders*)0L;
 //       Access: Static
 //  Description: ensure that the sound loaders map has been initialized
 ////////////////////////////////////////////////////////////////////
-static void check_sound_loaders(void) {
+static void check_sound_loaders() {
   if (_sound_loaders == (SoundLoaders*)0L)
     _sound_loaders = new SoundLoaders;
 }
@@ -40,7 +40,7 @@ static void check_sound_loaders(void) {
 //  Description: Initializes and/or returns the global pointer to the
 //               one AudioPool object in the system.
 ////////////////////////////////////////////////////////////////////
-AudioPool* AudioPool::get_ptr(void) {
+AudioPool* AudioPool::get_ptr() {
   if (_global_ptr == (AudioPool*)0L)
     _global_ptr = new AudioPool;
   audio_load_loaders();
@@ -140,7 +140,7 @@ void AudioPool::ns_release_sound(AudioSound* sound) {
 //       Access: Private
 //  Description: The nonstatic implementation of release_all_sounds().
 ////////////////////////////////////////////////////////////////////
-void AudioPool::ns_release_all_sounds(void) {
+void AudioPool::ns_release_all_sounds() {
   if (audio_cat.is_debug())
     audio_cat->debug() << "AudioPool: releasing all sounds" << endl;
   _sounds.clear();

panda/src/audio/audio_pool.h

@@ -29,15 +29,15 @@
 
 class EXPCL_PANDA AudioPool {
 private:
-  INLINE AudioPool(void);
+  INLINE AudioPool();
 
   bool ns_has_sound(Filename filename);
   AudioSound* ns_load_sound(Filename filename);
   void ns_release_sound(AudioSound* sound);
-  void ns_release_all_sounds(void);
+  void ns_release_all_sounds();
   string ns_get_nth_sound_name(int) const;
 
-  static AudioPool* get_ptr(void);
+  static AudioPool* get_ptr();
 
   static AudioPool *_global_ptr;
   typedef pmap<string, PT(AudioTraits::SoundClass) > SoundMap;
@@ -50,8 +50,8 @@ PUBLISHED:
   INLINE static bool verify_sound(const string& filename);
   INLINE static AudioSound* load_sound(const string& filename);
   INLINE static void release_sound(AudioSound* sound);
-  INLINE static void release_all_sounds(void);
-  INLINE static int get_num_loaded_sounds(void);
+  INLINE static void release_all_sounds();
+  INLINE static int get_num_loaded_sounds();
   INLINE static string get_nth_sound_name(int);
   static void register_sound_loader(const string&, SoundLoadFunc*);
 };

panda/src/audio/audio_sound.I

@@ -61,7 +61,7 @@ INLINE AudioSound& AudioSound::operator=(const AudioSound& c) {
 //       Access: Protected
 //  Description: return the player for this sound
 ////////////////////////////////////////////////////////////////////
-INLINE AudioTraits::PlayerClass* AudioSound::get_player(void) const {
+INLINE AudioTraits::PlayerClass* AudioSound::get_player() const {
   return _player;
 }
 
@@ -70,7 +70,7 @@ INLINE AudioTraits::PlayerClass* AudioSound::get_player(void) const {
 //       Access: Protected
 //  Description: return the trait sound class for this sound
 ////////////////////////////////////////////////////////////////////
-INLINE AudioTraits::SoundClass* AudioSound::get_sound(void) const {
+INLINE AudioTraits::SoundClass* AudioSound::get_sound() const {
   return _sound;
 }
 
@@ -79,7 +79,7 @@ INLINE AudioTraits::SoundClass* AudioSound::get_sound(void) const {
 //       Access: Protected
 //  Description: return the trait playing class for this sound
 ////////////////////////////////////////////////////////////////////
-INLINE AudioTraits::PlayingClass* AudioSound::get_state(void) const {
+INLINE AudioTraits::PlayingClass* AudioSound::get_state() const {
   return _state;
 }
 

panda/src/audio/audio_sound.cxx

@@ -28,7 +28,7 @@ TypeHandle AudioSound::_type_handle;
 //  Description: deletes the sound data and then lets the system
 //               destroy this structure
 ////////////////////////////////////////////////////////////////////
-AudioSound::~AudioSound(void) {
+AudioSound::~AudioSound() {
   if (audio_cat.is_debug())
     audio_cat->debug() << "AudioSound destructor (" << get_name() << ")"
                << endl;
@@ -41,7 +41,7 @@ AudioSound::~AudioSound(void) {
 //       Access: Public
 //  Description: return the length (in seconds) of the sound
 ////////////////////////////////////////////////////////////////////
-float AudioSound::length(void) const {
+float AudioSound::length() const {
   return _sound->length();
 }
 
@@ -50,7 +50,7 @@ float AudioSound::length(void) const {
 //       Access: Public
 //  Description: return the current play status of this sound
 ////////////////////////////////////////////////////////////////////
-AudioSound::SoundStatus AudioSound::status(void) const {
+AudioSound::SoundStatus AudioSound::status() const {
   AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
   switch (stat) {
   case AudioTraits::PlayingClass::BAD:

panda/src/audio/audio_sound.h

@@ -45,27 +45,27 @@ protected:
   INLINE AudioSound(const AudioSound&);
   INLINE AudioSound& operator=(const AudioSound&);
 
-  INLINE AudioTraits::PlayerClass* get_player(void) const;
-  INLINE AudioTraits::SoundClass* get_sound(void) const;
-  INLINE AudioTraits::PlayingClass* get_state(void) const;
+  INLINE AudioTraits::PlayerClass* get_player() const;
+  INLINE AudioTraits::SoundClass* get_sound() const;
+  INLINE AudioTraits::PlayingClass* get_state() const;
 
   friend class AudioPool;
   friend class AudioManager;
 PUBLISHED:
-  virtual ~AudioSound(void);
+  virtual ~AudioSound();
   INLINE bool operator==(const AudioSound&) const;
   INLINE bool operator!=(const AudioSound&) const;
 
   enum SoundStatus { BAD, READY, PLAYING } ;
 
-  float length(void) const;
-  SoundStatus status(void) const;
+  float length() const;
+  SoundStatus status() const;
 public:
   // type stuff
-  static TypeHandle get_class_type(void) {
+  static TypeHandle get_class_type() {
     return _type_handle;
   }
-  static void init_type(void) {
+  static void init_type() {
     /*
     TypedObject::init_type();
     register_type(_type_handle, "AudioSound",
@@ -75,10 +75,10 @@ public:
     register_type(_type_handle, "AudioSound",
                   TypedReferenceCount::get_class_type());
   }
-  virtual TypeHandle get_type(void) const {
+  virtual TypeHandle get_type() const {
     return get_class_type();
   }
-  virtual TypeHandle force_init_type(void) {
+  virtual TypeHandle force_init_type() {
     init_type();
     return get_class_type();
   }

panda/src/audio/audio_trait.cxx

@@ -19,40 +19,40 @@
 #include "audio_trait.h"
 #include "config_audio.h"
 
-AudioTraits::SoundClass::~SoundClass(void) {
+AudioTraits::SoundClass::~SoundClass() {
 }
 
-float AudioTraits::SoundClass::length(void) const {
+float AudioTraits::SoundClass::length() const {
   audio_cat->error() << "In abstract SoundClass::length!" << endl;
   return -1.;
 }
 
-AudioTraits::PlayingClass* AudioTraits::SoundClass::get_state(void) const {
+AudioTraits::PlayingClass* AudioTraits::SoundClass::get_state() const {
   audio_cat->error() << "In abstract SoundClass::get_state!" << endl;
   return (AudioTraits::PlayingClass*)0L;
 }
 
-AudioTraits::PlayerClass* AudioTraits::SoundClass::get_player(void) const {
+AudioTraits::PlayerClass* AudioTraits::SoundClass::get_player() const {
   audio_cat->error() << "In abstract SoundClass::get_player!" << endl;
   return (AudioTraits::PlayerClass*)0L;
 }
 
 AudioTraits::DeletePlayingFunc*
-AudioTraits::SoundClass::get_delstate(void) const {
+AudioTraits::SoundClass::get_delstate() const {
   audio_cat->error() << "In abstract SoundClass::get_delstate!" << endl;
   return (AudioTraits::DeletePlayingFunc*)0L;
 }
 
-AudioTraits::PlayingClass::~PlayingClass(void) {
+AudioTraits::PlayingClass::~PlayingClass() {
 }
 
 AudioTraits::PlayingClass::PlayingStatus
-AudioTraits::PlayingClass::status(void) {
+AudioTraits::PlayingClass::status() {
   audio_cat->error() << "In abstract PlayingClass::status!" << endl;
   return BAD;
 }
 
-AudioTraits::PlayerClass::~PlayerClass(void) {
+AudioTraits::PlayerClass::~PlayerClass() {
 }
 
 void AudioTraits::PlayerClass::play_sound(AudioTraits::SoundClass*,

panda/src/audio/audio_trait.h

@@ -33,13 +33,13 @@ public:
 
   class EXPCL_PANDA SoundClass : public ReferenceCount {
   public:
-    SoundClass(void) {}
-    virtual ~SoundClass(void);
+    SoundClass() {}
+    virtual ~SoundClass();
 
-    virtual float length(void) const = 0;
-    virtual PlayingClass* get_state(void) const = 0;
-    virtual PlayerClass* get_player(void) const = 0;
-    virtual DeletePlayingFunc* get_delstate(void) const = 0;
+    virtual float length() const = 0;
+    virtual PlayingClass* get_state() const = 0;
+    virtual PlayerClass* get_player() const = 0;
+    virtual DeletePlayingFunc* get_delstate() const = 0;
   };
   class EXPCL_PANDA PlayingClass {
   protected:
@@ -47,18 +47,18 @@ public:
     float _volume;
   public:
     PlayingClass(SoundClass* s) : _sound(s), _volume(1.) {}
-    virtual ~PlayingClass(void);
+    virtual ~PlayingClass();
 
     enum PlayingStatus { BAD, READY, PLAYING } ;
 
-    virtual PlayingStatus status(void) = 0;
+    virtual PlayingStatus status() = 0;
     INLINE void set_volume(float v) { _volume = v; }
-    INLINE float get_volume(void) const { return _volume; }
+    INLINE float get_volume() const { return _volume; }
   };
   class EXPCL_PANDA PlayerClass {
   public:
-    PlayerClass(void) {}
-    virtual ~PlayerClass(void);
+    PlayerClass() {}
+    virtual ~PlayerClass();
 
     virtual void play_sound(SoundClass*, PlayingClass*, float) = 0;
     virtual void stop_sound(SoundClass*, PlayingClass*) = 0;

panda/src/audio/audio_win_traits.I

@@ -16,43 +16,43 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-INLINE WinSample::WinSample(void) : AudioTraits::SoundClass(), _data(NULL),
+INLINE WinSample::WinSample() : AudioTraits::SoundClass(), _data(NULL),
                                     _len(0) {
 }
 
-INLINE DWORD WinSample::get_length(void) const {
+INLINE DWORD WinSample::get_length() const {
   return _len;
 }
 
-INLINE WAVEFORMATEX WinSample::get_format(void) const {
+INLINE WAVEFORMATEX WinSample::get_format() const {
   return _info;
 }
 
-INLINE WinMusic::WinMusic(void) : AudioTraits::SoundClass(),
+INLINE WinMusic::WinMusic() : AudioTraits::SoundClass(),
                                   _performance(NULL), _music(NULL),
                                   _buffer(NULL), _synth(NULL) {
   init();
 }
 
-INLINE IDirectMusicPerformance* WinMusic::get_performance(void) const {
+INLINE IDirectMusicPerformance* WinMusic::get_performance() const {
   return _performance;
 }
 
-INLINE IDirectMusicSegment* WinMusic::get_music(void) {
+INLINE IDirectMusicSegment* WinMusic::get_music() {
   return _music;
 }
 
-INLINE LPDIRECTSOUNDBUFFER WinSamplePlaying::get_channel(void) {
+INLINE LPDIRECTSOUNDBUFFER WinSamplePlaying::get_channel() {
   return _channel;
 }
 
-INLINE IDirectMusicPerformance* WinMusicPlaying::get_performance(void) const {
+INLINE IDirectMusicPerformance* WinMusicPlaying::get_performance() const {
   WinMusic* wmusic = (WinMusic*)_sound;
   return wmusic->get_performance();
 }
 
-INLINE WinSamplePlayer::WinSamplePlayer(void) : AudioTraits::PlayerClass() {
+INLINE WinSamplePlayer::WinSamplePlayer() : AudioTraits::PlayerClass() {
 }
 
-INLINE WinMusicPlayer::WinMusicPlayer(void) : AudioTraits::PlayerClass() {
+INLINE WinMusicPlayer::WinMusicPlayer() : AudioTraits::PlayerClass() {
 }

panda/src/audio/audio_win_traits.cxx

@@ -333,17 +333,20 @@ HRESULT wave_read_file(HMMIO hmmio, UINT cbRead, BYTE* pbDest, MMCKINFO* pckIn,
   for (DWORD cT=0; cT<cbDataIn; ++cT) {
     // copy bytes from the io to the buffer
     if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead) {
-      if (mmioAdvance(hmmio, &mmioinfoIn, MMIO_READ) != 0)
-    return E_FAIL;
-      if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead)
-    return E_FAIL;
+      if (mmioAdvance(hmmio, &mmioinfoIn, MMIO_READ) != 0) {
+        return E_FAIL;
+      }
+      if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead) {
+        return E_FAIL;
+      }
     }
     // actual copy
     *((BYTE*)pbDest+cT) = *((BYTE*)mmioinfoIn.pchNext);
     mmioinfoIn.pchNext++;
   }
-  if (mmioSetInfo(hmmio, &mmioinfoIn, 0) != 0)
+  if (mmioSetInfo(hmmio, &mmioinfoIn, 0) != 0) {
     return E_FAIL;
+  }
   *cbActualRead = cbDataIn;
   return S_OK;
 }

panda/src/audio/audio_win_traits.h

@@ -37,17 +37,17 @@ public:
   DWORD _len;
   WAVEFORMATEX _info;
 public:
-  INLINE WinSample(void);
-  virtual ~WinSample(void);
+  INLINE WinSample();
+  virtual ~WinSample();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
 
   // used by play_sound
-  INLINE DWORD get_length(void) const;
-  INLINE WAVEFORMATEX get_format(void) const;
+  INLINE DWORD get_length() const;
+  INLINE WAVEFORMATEX get_format() const;
 public:
   static WinSample* load_wav(Filename);
   static WinSample* load_raw(unsigned char*, unsigned long);
@@ -60,20 +60,20 @@ private:
   IDirectSoundBuffer* _buffer;
   IDirectMusicPort* _synth;
 
-  void init(void);
+  void init();
 public:
-  INLINE WinMusic(void);
-  virtual ~WinMusic(void);
+  INLINE WinMusic();
+  virtual ~WinMusic();
 
-  virtual float length(void) const;
-  virtual AudioTraits::PlayingClass* get_state(void) const;
-  virtual AudioTraits::PlayerClass* get_player(void) const;
-  virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
+  virtual float length() const;
+  virtual AudioTraits::PlayingClass* get_state() const;
+  virtual AudioTraits::PlayerClass* get_player() const;
+  virtual AudioTraits::DeletePlayingFunc* get_delstate() const;
   // these are used by the loaders
   static WinMusic* load_midi(Filename);
   // these are used by the players
-  INLINE IDirectMusicPerformance* get_performance(void) const;
-  INLINE IDirectMusicSegment* get_music(void);
+  INLINE IDirectMusicPerformance* get_performance() const;
+  INLINE IDirectMusicSegment* get_music();
 };
 
 class EXPCL_PANDA WinSamplePlaying : public AudioTraits::PlayingClass {
@@ -82,31 +82,31 @@ private:
   BYTE* _data;
 public:
   WinSamplePlaying(AudioTraits::SoundClass*);
-  ~WinSamplePlaying(void);
+  ~WinSamplePlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
   // these are used by the laoders
-  BYTE* lock(void);
-  void  unlock(void);
+  BYTE* lock();
+  void  unlock();
   // these are used by the player
-  INLINE LPDIRECTSOUNDBUFFER get_channel(void);
+  INLINE LPDIRECTSOUNDBUFFER get_channel();
 };
 
 class EXPCL_PANDA WinMusicPlaying : public AudioTraits::PlayingClass {
 public:
   WinMusicPlaying(AudioTraits::SoundClass*);
-  ~WinMusicPlaying(void);
+  ~WinMusicPlaying();
 
-  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
+  virtual AudioTraits::PlayingClass::PlayingStatus status();
   static void destroy(AudioTraits::PlayingClass*);
-  INLINE IDirectMusicPerformance* get_performance(void) const;
+  INLINE IDirectMusicPerformance* get_performance() const;
 };
 
 class EXPCL_PANDA WinSamplePlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE WinSamplePlayer(void);
-  virtual ~WinSamplePlayer(void);
+  INLINE WinSamplePlayer();
+  virtual ~WinSamplePlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -116,15 +116,15 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static WinSamplePlayer* get_instance(void);
+  static WinSamplePlayer* get_instance();
 private:
   static WinSamplePlayer* _global_instance;
 };
 
 class EXPCL_PANDA WinMusicPlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE WinMusicPlayer(void);
-  virtual ~WinMusicPlayer(void);
+  INLINE WinMusicPlayer();
+  virtual ~WinMusicPlayer();
 
   virtual void play_sound(AudioTraits::SoundClass*,
                           AudioTraits::PlayingClass*, float);
@@ -134,7 +134,7 @@ public:
   virtual bool adjust_volume(AudioTraits::PlayingClass*);
 public:
   // used by the readers
-  static WinMusicPlayer* get_instance(void);
+  static WinMusicPlayer* get_instance();
 private:
   static WinMusicPlayer* _global_instance;
 };

panda/src/audio/config_audio.cxx

@@ -82,7 +82,7 @@ ConfigureFn(config_audio) {
     audio_thread_priority = -1;
 }
 
-void audio_load_loaders(void) {
+void audio_load_loaders() {
   static bool did_load = false;
 
   if (did_load)

panda/src/audio/config_audio.h

@@ -39,6 +39,6 @@ extern EXPCL_PANDA float audio_master_sfx_volume;
 extern EXPCL_PANDA float audio_master_music_volume;
 extern EXPCL_PANDA int audio_thread_priority;
 
-extern EXPCL_PANDA void audio_load_loaders(void);
+extern EXPCL_PANDA void audio_load_loaders();
 
 #endif /* __CONFIG_AUDIO_H__ */