(void) -> ()

panda/src/chan/animBundle.I

@@ -34,7 +34,7 @@ AnimBundle(const string &name, float fps, int num_frames) : AnimGroup(name) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE AnimBundle::
-AnimBundle(void) {
+AnimBundle() {
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/chan/animBundle.cxx

@@ -91,7 +91,7 @@ make_AnimBundle(const FactoryParams &params)
 //  Description: Factory method to generate a AnimBundle object
 ////////////////////////////////////////////////////////////////////
 void AnimBundle::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_AnimBundle);
 }

panda/src/chan/animBundle.h

@@ -42,13 +42,13 @@ PUBLISHED:
   virtual void output(ostream &out) const;
 
 protected:
-  INLINE AnimBundle(void);
+  INLINE AnimBundle();
 
   float _fps;
   int _num_frames;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
 
   static TypedWritable *make_AnimBundle(const FactoryParams &params);

panda/src/chan/animChannelMatrixXfmTable.h

@@ -71,7 +71,7 @@ protected:
   CPTA_float _tables[num_matrix_components];
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
 
   static TypedWritable *make_AnimChannelMatrixXfmTable(const FactoryParams &params);

panda/src/chan/animChannelScalarTable.cxx

@@ -46,7 +46,7 @@ AnimChannelScalarTable(AnimGroup *parent, const string &name)
 //  Description:
 ////////////////////////////////////////////////////////////////////
 AnimChannelScalarTable::
-AnimChannelScalarTable(void){
+AnimChannelScalarTable(){
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -330,7 +330,7 @@ make_AnimChannelScalarTable(const FactoryParams &params)
 //  Description: Factory method to generate a AnimChannelScalarTable object
 ////////////////////////////////////////////////////////////////////
 void AnimChannelScalarTable::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_AnimChannelScalarTable);
 }

panda/src/chan/animChannelScalarTable.h

@@ -49,11 +49,11 @@ public:
   virtual void write(ostream &out, int indent_level) const;
 
 protected:
-  AnimChannelScalarTable(void);
+  AnimChannelScalarTable();
   CPTA_float _table;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
 
   static TypedWritable *make_AnimChannelScalarTable(const FactoryParams &params);

panda/src/chan/animGroup.cxx

@@ -366,7 +366,7 @@ make_AnimGroup(const FactoryParams &params)
 //  Description: Factory method to generate a AnimGroup object
 ////////////////////////////////////////////////////////////////////
 void AnimGroup::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_AnimGroup);
 }

panda/src/chan/animGroup.h

@@ -74,7 +74,7 @@ protected:
   AnimBundle *_root;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
   virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);

panda/src/chan/movingPart.I

@@ -68,7 +68,7 @@ MovingPart(PartGroup *parent, const string &name,
 ////////////////////////////////////////////////////////////////////
 template<class SwitchType>
 INLINE MovingPart<SwitchType>::
-MovingPart(void) {
+MovingPart() {
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/chan/movingPart.h

@@ -54,7 +54,7 @@ public:
   INLINE virtual void write_datagram(BamWriter* manager, Datagram &me);
 
 protected:
-  INLINE MovingPart(void);
+  INLINE MovingPart();
   INLINE void fillin(DatagramIterator& scan, BamReader* manager);
 
 public:

panda/src/chan/movingPartBase.cxx

@@ -42,7 +42,7 @@ MovingPartBase(PartGroup *parent, const string &name)
 //  Description:
 ////////////////////////////////////////////////////////////////////
 MovingPartBase::
-MovingPartBase(void){
+MovingPartBase(){
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/chan/movingPartBase.h

@@ -61,7 +61,7 @@ public:
                                 bool parent_changed);
 
 protected:
-  MovingPartBase(void);
+  MovingPartBase();
 
   virtual void pick_channel_index(plist<int> &holes, int &next) const;
   virtual void bind_hierarchy(AnimGroup *anim, int channel_index);

panda/src/chan/movingPartMatrix.I

@@ -46,5 +46,5 @@ MovingPartMatrix(PartGroup *parent, const string &name,
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE MovingPartMatrix::
-MovingPartMatrix(void) {
+MovingPartMatrix() {
 }

panda/src/chan/movingPartMatrix.cxx

@@ -165,7 +165,7 @@ make_MovingPartMatrix(const FactoryParams &params)
 //  Description: Factory method to generate a MovingPartMatrix object
 ////////////////////////////////////////////////////////////////////
 void MovingPartMatrix::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_MovingPartMatrix);
 }

panda/src/chan/movingPartMatrix.h

@@ -45,10 +45,10 @@ public:
   virtual void get_blend_value(const PartBundle *root);
 
 protected:
-  INLINE MovingPartMatrix(void);
+  INLINE MovingPartMatrix();
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
 
   static TypedWritable *make_MovingPartMatrix(const FactoryParams &params);
 

panda/src/chan/movingPartScalar.I

@@ -46,5 +46,5 @@ MovingPartScalar(PartGroup *parent, const string &name,
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE MovingPartScalar::
-MovingPartScalar(void){
+MovingPartScalar(){
 }

panda/src/chan/movingPartScalar.cxx

@@ -116,7 +116,7 @@ make_MovingPartScalar(const FactoryParams &params)
 //  Description: Factory method to generate a MovingPartScalar object
 ////////////////////////////////////////////////////////////////////
 void MovingPartScalar::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_MovingPartScalar);
 }

panda/src/chan/movingPartScalar.h

@@ -44,10 +44,10 @@ public:
   virtual void get_blend_value(const PartBundle *root);
 
 protected:
-  INLINE MovingPartScalar(void);
+  INLINE MovingPartScalar();
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
 
   static TypedWritable *make_MovingPartScalar(const FactoryParams &params);
 

panda/src/chan/partBundle.cxx

@@ -462,7 +462,7 @@ make_PartBundle(const FactoryParams &params)
 //  Description: Factory method to generate a PartBundle object
 ////////////////////////////////////////////////////////////////////
 void PartBundle::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_PartBundle);
 }

panda/src/chan/partBundle.h

@@ -141,7 +141,7 @@ protected:
   bool _anim_changed;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void finalize(BamReader *manager);
 
   static TypedWritable *make_PartBundle(const FactoryParams &params);

panda/src/chan/partGroup.cxx

@@ -551,7 +551,7 @@ make_PartGroup(const FactoryParams &params)
 //  Description: Factory method to generate a PartGroup object
 ////////////////////////////////////////////////////////////////////
 void PartGroup::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_PartGroup);
 }

panda/src/chan/partGroup.h

@@ -97,7 +97,7 @@ protected:
   Children _children;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
   virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);

panda/src/char/characterJoint.cxx

@@ -396,7 +396,7 @@ make_CharacterJoint(const FactoryParams &params)
 //  Description: Factory method to generate a CharacterJoint object
 ////////////////////////////////////////////////////////////////////
 void CharacterJoint::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_CharacterJoint);
 }

panda/src/char/characterJoint.h

@@ -69,7 +69,7 @@ private:
   VertexTransforms _vertex_transforms;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
   virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);

panda/src/char/characterJointBundle.cxx

@@ -68,7 +68,7 @@ make_CharacterJointBundle(const FactoryParams &params)
 //  Description: Factory method to generate a CharacterJointBundle object
 ////////////////////////////////////////////////////////////////////
 void CharacterJointBundle::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_CharacterJointBundle);
 }

panda/src/char/characterJointBundle.h

@@ -45,7 +45,7 @@ PUBLISHED:
 public:
   virtual PartGroup *make_copy() const;
 
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
 
   static TypedWritable *make_CharacterJointBundle(const FactoryParams &params);
 

panda/src/char/characterSlider.cxx

@@ -122,7 +122,7 @@ make_CharacterSlider(const FactoryParams &params)
 //  Description: Factory method to generate a CharacterSlider object
 ////////////////////////////////////////////////////////////////////
 void CharacterSlider::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_CharacterSlider);
 }

panda/src/collide/collisionNode.h

@@ -98,15 +98,15 @@ protected:
   void fillin(DatagramIterator &scan, BamReader *manager);
 
 public:
-  static TypeHandle get_class_type(void) {
+  static TypeHandle get_class_type() {
     return _type_handle;
   }
-  static void init_type(void) {
+  static void init_type() {
     PandaNode::init_type();
     register_type(_type_handle, "CollisionNode",
                   PandaNode::get_class_type());
   }
-  virtual TypeHandle get_type(void) const {
+  virtual TypeHandle get_type() const {
     return get_class_type();
   }
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}

panda/src/collide/collisionPlane.cxx

@@ -406,7 +406,7 @@ make_CollisionPlane(const FactoryParams &params)
 //  Description: Factory method to generate a CollisionPlane object
 ////////////////////////////////////////////////////////////////////
 void CollisionPlane::
-register_with_read_factory(void)
+register_with_read_factory()
 {
   BamReader::get_factory()->register_factory(get_class_type(), make_CollisionPlane);
 }

panda/src/collide/collisionPlane.h

@@ -72,7 +72,7 @@ private:
   Planef _plane;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
 
   static TypedWritable *make_CollisionPlane(const FactoryParams &params);

panda/src/collide/collisionPolygon.h

@@ -119,7 +119,7 @@ private:
   LMatrix4f _to_2d_mat;
 
 public:
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
   virtual void write_datagram(BamWriter* manager, Datagram &me);
 
   static TypedWritable *make_CollisionPolygon(const FactoryParams &params);

panda/src/display/graphicsStateGuardian.I

@@ -717,7 +717,7 @@ set_transform(const TransformState *transform) {
 //               a call to prepare_display_region().
 ////////////////////////////////////////////////////////////////////
 INLINE const DisplayRegion *GraphicsStateGuardian::
-get_current_display_region(void) const {
+get_current_display_region() const {
   return _current_display_region;
 }
 

panda/src/display/graphicsStateGuardian.h

@@ -212,7 +212,7 @@ public:
 
   RenderBuffer get_render_buffer(int buffer_type);
 
-  INLINE const DisplayRegion *get_current_display_region(void) const;
+  INLINE const DisplayRegion *get_current_display_region() const;
   INLINE const Lens *get_current_lens() const;
 
   INLINE DisplayRegionStack push_display_region(const DisplayRegion *dr);

panda/src/doc/particle_system_parameters.txt

@@ -32,7 +32,7 @@ Particle Systems
 CLASS: ParticleSystem
 
 Particle systems have the following methods:
-  void render(void); // renders the particle system's particles*
+  void render(); // renders the particle system's particles*
   void update(float dt); // updates the state of the particle system for "dt" seconds of elapsed time*
 
 *NOTE: render() and update() should not be called for a particle system that is attached to a
@@ -360,7 +360,7 @@ systems can be attached to a single ParticleSystemManager.
 Particle system managers have the following methods:
   void attach_particlesystem(ParticleSystem *ps); // attach a particle system to this manager
   void remove_particlesystem(ParticleSystem *ps); // un-attach a particle system from this manager
-  void clear(void);             // un-attach all particle systems from this manager
+  void clear();             // un-attach all particle systems from this manager
   void do_particles(float dt);  // update all attached particle systems for "dt" seconds of elapsed time
 
 Particle system managers have the following parameter:

panda/src/downloader/asyncUtility.I

@@ -32,6 +32,6 @@ set_frequency(float frequency) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE float AsyncUtility::
-get_frequency(void) const {
+get_frequency() const {
   return _frequency;
 }

panda/src/downloader/asyncUtility.cxx

@@ -66,7 +66,7 @@ AsyncUtility::
 //  Description:
 ////////////////////////////////////////////////////////////////////
 void AsyncUtility::
-create_thread(void) {
+create_thread() {
 #ifdef OLD_HAVE_IPC
   if (_threaded == false && _threads_enabled == true) {
     downloader_cat.debug()
@@ -83,7 +83,7 @@ create_thread(void) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 void AsyncUtility::
-destroy_thread(void) {
+destroy_thread() {
 #ifdef OLD_HAVE_IPC
   if (_threaded == false)
     return;
@@ -130,7 +130,7 @@ st_callback(void *arg) {
 //               forever for a request to show up, and then serves it.
 ////////////////////////////////////////////////////////////////////
 void AsyncUtility::
-callback(void) {
+callback() {
 #ifdef OLD_HAVE_IPC
   while (process_request()) {
     // Sleep until a signal arrives
@@ -147,7 +147,7 @@ callback(void) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 void AsyncUtility::
-nap(void) const {
+nap() const {
 #ifdef OLD_HAVE_IPC
 #ifdef WIN32
   _sleep((DWORD)(1000 * _frequency));

panda/src/downloader/asyncUtility.h

@@ -39,20 +39,20 @@
 class EXPCL_PANDAEXPRESS AsyncUtility {
 PUBLISHED:
   INLINE void set_frequency(float frequency);
-  INLINE float get_frequency(void) const;
+  INLINE float get_frequency() const;
 
-  void create_thread(void);
+  void create_thread();
 
 public:
   AsyncUtility(float frequency = 0.2);
-  virtual ~AsyncUtility(void);
+  virtual ~AsyncUtility();
 
 protected:
-  void destroy_thread(void);
+  void destroy_thread();
   static void* st_callback(void *arg);
-  void callback(void);
-  virtual bool process_request(void) = 0;
-  void nap(void) const;
+  void callback();
+  virtual bool process_request() = 0;
+  void nap() const;
 
 protected:
   int _next_token;

panda/src/downloader/bioStreamBuf.h

@@ -44,8 +44,8 @@ public:
 
 protected:
   virtual int overflow(int c);
-  virtual int sync(void);
-  virtual int underflow(void);
+  virtual int sync();
+  virtual int underflow();
 
 private:
   size_t write_chars(const char *start, size_t length);

panda/src/downloader/chunkedStreamBuf.h

@@ -43,7 +43,7 @@ public:
   void close_read();
 
 protected:
-  virtual int underflow(void);
+  virtual int underflow();
 
 private:
   size_t read_chars(char *start, size_t length);

panda/src/downloader/decompressor.h

@@ -48,7 +48,7 @@ PUBLISHED:
   float get_progress() const;
 
 private:
-  void cleanup(void);
+  void cleanup();
 
   Filename _source_filename;
   

panda/src/downloader/downloadDb.I

@@ -23,7 +23,7 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE int DownloadDb::
-get_client_num_multifiles(void) const {
+get_client_num_multifiles() const {
   return _client_db.get_num_multifiles();
 }
 
@@ -33,7 +33,7 @@ get_client_num_multifiles(void) const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE int DownloadDb::
-get_server_num_multifiles(void) const {
+get_server_num_multifiles() const {
   return _server_db.get_num_multifiles();
 }
 

panda/src/downloader/downloadDb.cxx

@@ -89,7 +89,7 @@ DownloadDb(Filename &server_file, Filename &client_file) {
 //  Description: Primarily used for testing.
 ////////////////////////////////////////////////////////////////////
 DownloadDb::
-DownloadDb(void) {
+DownloadDb() {
   _client_db = Db();
   _server_db = Db();
 }
@@ -100,7 +100,7 @@ DownloadDb(void) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 DownloadDb::
-~DownloadDb(void) {
+~DownloadDb() {
   if (downloader_cat.is_debug())
     downloader_cat.debug()
       << "DownloadDb destructor called" << endl;    
@@ -394,7 +394,7 @@ write_db(Filename &file, Db db, bool want_server_info) {
 //               new clean server db
 ////////////////////////////////////////////////////////////////////
 void DownloadDb::
-create_new_server_db(void) {
+create_new_server_db() {
   _server_db = Db();
 }
 
@@ -449,7 +449,7 @@ server_add_file(string mfname, string fname) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 DownloadDb::MultifileRecord::
-MultifileRecord(void) {
+MultifileRecord() {
   _name = "";
   _phase = 0;
   _size = 0;
@@ -499,7 +499,7 @@ write(ostream &out) const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 int DownloadDb::MultifileRecord::
-get_num_files(void) const {
+get_num_files() const {
   return _file_records.size();
 }
 
@@ -578,7 +578,7 @@ add_file_record(PT(FileRecord) fr) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 DownloadDb::Db::
-Db(void) {
+Db() {
   // The head is a magic number and the number of multifiles in the db
   _header_length = sizeof(_magic_number) + sizeof(PN_int32);
 }
@@ -604,7 +604,7 @@ write(ostream &out) const {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 int DownloadDb::Db::
-get_num_multifiles(void) const {
+get_num_multifiles() const {
   return _mfile_records.size();
 }
 
@@ -1030,7 +1030,7 @@ write_header(ostream &write_stream) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 DownloadDb::FileRecord::
-FileRecord(void) {
+FileRecord() {
   _name = "";
 }
 

panda/src/downloader/downloadDb.h

@@ -81,10 +81,10 @@ PUBLISHED:
     Status_extracted = 3
   };
 
-  DownloadDb(void);
+  DownloadDb();
   DownloadDb(Ramfile &server_file, Filename &client_file);
   DownloadDb(Filename &server_file, Filename &client_file);
-  ~DownloadDb(void);
+  ~DownloadDb();
 
   void output(ostream &out) const;
   void write(ostream &out) const;
@@ -94,8 +94,8 @@ PUBLISHED:
   bool write_client_db(Filename &file);
   bool write_server_db(Filename &file);
 
-  INLINE int get_client_num_multifiles(void) const;
-  INLINE int get_server_num_multifiles(void) const;
+  INLINE int get_client_num_multifiles() const;
+  INLINE int get_server_num_multifiles() const;
 
   INLINE string get_client_multifile_name(int index) const;
   INLINE string get_server_multifile_name(int index) const;
@@ -143,7 +143,7 @@ public:
 
   class EXPCL_PANDAEXPRESS FileRecord : public ReferenceCount {
   public:
-    FileRecord(void);
+    FileRecord();
     FileRecord(string name);
     void write(ostream &out) const;
     string _name;
@@ -153,10 +153,10 @@ public:
 
   class EXPCL_PANDAEXPRESS MultifileRecord : public ReferenceCount {
   public:
-    MultifileRecord(void);
+    MultifileRecord();
     MultifileRecord(string name, Phase phase, int size, int status);
     void write(ostream &out) const;
-    int get_num_files(void) const;
+    int get_num_files() const;
     string get_file_name(int index) const;
     bool file_exists(string fname) const;
     PT(FileRecord) get_file_record_named(string fname) const;
@@ -174,9 +174,9 @@ public:
 
   class EXPCL_PANDAEXPRESS Db {
   public:
-    Db(void);
+    Db();
     void write(ostream &out) const;
-    int get_num_multifiles(void) const;
+    int get_num_multifiles() const;
     string get_multifile_name(int index) const;
     bool multifile_exists(string mfname) const;
     PT(MultifileRecord) get_multifile_record_named(string mfname) const;

panda/src/downloader/extractor.h

@@ -53,7 +53,7 @@ PUBLISHED:
   int request_all_subfiles();
 
   int step();
-  float get_progress(void) const;
+  float get_progress() const;
 
   bool run();
 

panda/src/downloader/identityStreamBuf.h

@@ -43,7 +43,7 @@ public:
   void close_read();
 
 protected:
-  virtual int underflow(void);
+  virtual int underflow();
 
 private:
   size_t read_chars(char *start, size_t length);

panda/src/downloader/patcher.I

@@ -22,7 +22,7 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE float Patcher::
-get_progress(void) const {
+get_progress() const {
   if(_patchfile) {
     return _patchfile->get_progress();
   }

panda/src/downloader/patcher.cxx

@@ -30,7 +30,7 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 Patcher::
-Patcher(void) {
+Patcher() {
   PT(Buffer) buffer = new Buffer(patcher_buffer_size);
   init(buffer);
 }
@@ -65,7 +65,7 @@ init(PT(Buffer) buffer) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 Patcher::
-~Patcher(void) {
+~Patcher() {
   delete _patchfile;
 }
 
@@ -85,7 +85,7 @@ initiate(Filename &patch, Filename &infile) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 int Patcher::
-run(void) {
+run() {
   return _patchfile->run();
 }
 

panda/src/downloader/patcher.h

@@ -33,14 +33,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDAEXPRESS Patcher {
 PUBLISHED:
-  Patcher(void);
+  Patcher();
   Patcher(PT(Buffer) buffer);
-  virtual ~Patcher(void);
+  virtual ~Patcher();
 
   int initiate(Filename &patch, Filename &infile);
-  int run(void);
+  int run();
 
-  INLINE float get_progress(void) const;
+  INLINE float get_progress() const;
 
 private:
   void init(PT(Buffer) buffer);

panda/src/dxgsg7/dxGraphicsStateGuardian7.cxx

@@ -327,7 +327,7 @@ set_context(DXScreenData *pNewContextData) {
 
 // recreate dx objects without modifying gsg state, other than clearing state cache
 void DXGraphicsStateGuardian7::
-free_dxgsg_objects(void) {
+free_dxgsg_objects() {
     ULONG refcnt;
 
     free_pointers();
@@ -3512,7 +3512,7 @@ framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr,
 
   tex->setup_2d_texture(w, h, Texture::T_unsigned_byte, Texture::F_rgb);
   
-  (void) ConvertDDSurftoPixBuf(tex,((_cur_read_pixel_buffer & RenderBuffer::T_back) ? _pScrn->pddsBack : _pScrn->pddsPrimary));
+  () ConvertDDSurftoPixBuf(tex,((_cur_read_pixel_buffer & RenderBuffer::T_back) ? _pScrn->pddsBack : _pScrn->pddsPrimary));
   
   nassertr(tex->has_ram_image(), false);
   return true;
@@ -4562,15 +4562,15 @@ free_pointers() {
 #endif
 }
 
-TypeHandle DXGraphicsStateGuardian7::get_type(void) const {
+TypeHandle DXGraphicsStateGuardian7::get_type() const {
     return get_class_type();
 }
 
-TypeHandle DXGraphicsStateGuardian7::get_class_type(void) {
+TypeHandle DXGraphicsStateGuardian7::get_class_type() {
     return _type_handle;
 }
 
-void DXGraphicsStateGuardian7::init_type(void) {
+void DXGraphicsStateGuardian7::init_type() {
     GraphicsStateGuardian::init_type();
     register_type(_type_handle, "DXGraphicsStateGuardian7",
                   GraphicsStateGuardian::get_class_type());
@@ -4816,7 +4816,7 @@ bool recreate_tex_callback(TextureContext *tc,void *void_dxgsg7_ptr) {
 }
 
 // release all textures and vertex/index buffers
-HRESULT DXGraphicsStateGuardian7::DeleteAllVideoSurfaces(void) {
+HRESULT DXGraphicsStateGuardian7::DeleteAllVideoSurfaces() {
   // BUGBUG: need to handle vertexbuffer handling here
 
   // cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
@@ -4828,7 +4828,7 @@ HRESULT DXGraphicsStateGuardian7::DeleteAllVideoSurfaces(void) {
 }
 
 // recreate all textures and vertex/index buffers
-HRESULT DXGraphicsStateGuardian7::RecreateAllVideoSurfaces(void) {
+HRESULT DXGraphicsStateGuardian7::RecreateAllVideoSurfaces() {
   // BUGBUG: need to handle vertexbuffer handling here
 
   // cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
@@ -4839,7 +4839,7 @@ HRESULT DXGraphicsStateGuardian7::RecreateAllVideoSurfaces(void) {
   return S_OK;
 }
 
-HRESULT DXGraphicsStateGuardian7::RestoreAllVideoSurfaces(void) {
+HRESULT DXGraphicsStateGuardian7::RestoreAllVideoSurfaces() {
   // BUGBUG: this should also restore vertex buffer contents when they are implemented
   // You will need to destroy and recreate
   // optimized vertex buffers however, restoring is not enough.
@@ -4867,7 +4867,7 @@ HRESULT DXGraphicsStateGuardian7::RestoreAllVideoSurfaces(void) {
 //       Access:
 //       Description:   Repaint primary buffer from back buffer
 ////////////////////////////////////////////////////////////////////
-void DXGraphicsStateGuardian7::show_frame(void) {
+void DXGraphicsStateGuardian7::show_frame() {
   if(_pScrn->pddsPrimary==NULL)
     return;
 
@@ -4929,7 +4929,7 @@ support_overlay_window(bool flag) {
 //       Access:
 //       Description:   Repaint primary buffer from back buffer
 ////////////////////////////////////////////////////////////////////
-void DXGraphicsStateGuardian7::show_full_screen_frame(void) {
+void DXGraphicsStateGuardian7::show_full_screen_frame() {
   HRESULT hr;
 
   // Flip the front and back buffers, to make what we just rendered
@@ -4974,7 +4974,7 @@ void DXGraphicsStateGuardian7::show_full_screen_frame(void) {
 //  Description: Repaint primary buffer from back buffer (windowed
 //               mode only)
 ////////////////////////////////////////////////////////////////////
-void DXGraphicsStateGuardian7::show_windowed_frame(void) {
+void DXGraphicsStateGuardian7::show_windowed_frame() {
   HRESULT hr;
 
   DX_DECLARE_CLEAN(DDBLTFX, bltfx);

panda/src/dxgsg7/dxGraphicsStateGuardian7.h

@@ -124,7 +124,7 @@ public:
   virtual void end_scene();
   virtual void end_frame();
 
-  virtual bool wants_texcoords(void) const;
+  virtual bool wants_texcoords() const;
 
   virtual void set_color_clear_value(const Colorf& value);
 
@@ -150,7 +150,7 @@ protected:
   virtual void set_blend_mode();
 
   void free_pointers();            // free local internal buffers
-  void free_dxgsg_objects(void);   // free the DirectX objects we create
+  void free_dxgsg_objects();   // free the DirectX objects we create
 
   void set_draw_buffer(const RenderBuffer &rb);
   void set_read_buffer(const RenderBuffer &rb);
@@ -177,9 +177,9 @@ protected:
                     D3DVECTOR *pCenter, float fRadius,
                     DWORD wNumRings, DWORD wNumSections, float sx, float sy, float sz,
                     DWORD *pNumVertices,DWORD *pNumIndices,DWORD fvfFlags,DWORD dwVertSize);
-  HRESULT RestoreAllVideoSurfaces(void);
-  HRESULT RecreateAllVideoSurfaces(void);
-  HRESULT DeleteAllVideoSurfaces(void);
+  HRESULT RestoreAllVideoSurfaces();
+  HRESULT RecreateAllVideoSurfaces();
+  HRESULT DeleteAllVideoSurfaces();
 
 /*
   INLINE void enable_multisample_alpha_one(bool val);
@@ -321,14 +321,14 @@ public:
   static GraphicsStateGuardian*
   make_DXGraphicsStateGuardian(const FactoryParams &params);
 
-  static TypeHandle get_class_type(void);
-  static void init_type(void);
-  virtual TypeHandle get_type(void) const;
+  static TypeHandle get_class_type();
+  static void init_type();
+  virtual TypeHandle get_type() const;
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
 //  INLINE void Set_HDC(HDC hdc)  {  _front_hdc = hdc;  }
   void adjust_view_rect(int x, int y);
   INLINE void SetDXReady(bool stat)  {  _dx_ready = stat; }
-  INLINE bool GetDXReady(void)  { return _dx_ready;}
+  INLINE bool GetDXReady()  { return _dx_ready;}
   void DXGraphicsStateGuardian7::SetTextureBlendMode(TextureStage::Mode TexBlendMode,bool bJustEnable);
 
   void  dx_cleanup(bool bRestoreDisplayMode,bool bAtExitFnCalled);
@@ -351,7 +351,7 @@ public:
           LPDIRECT3D7          d3d,
           LPDIRECT3DDEVICE7    d3dDevice,
           RECT  viewrect); */
-  void dx_init(void);
+  void dx_init();
   
   friend HRESULT CALLBACK EnumTexFmtsCallback( LPDDPIXELFORMAT pddpf, VOID* param );
 

panda/src/dxgsg7/dxTextureContext7.cxx

@@ -1657,7 +1657,7 @@ downsample_image(uchar *source, int num_pixels, int component_width) {
 }
 
 HRESULT DXTextureContext7::
-FillDDSurfTexturePixels(void) {
+FillDDSurfTexturePixels() {
     
     CPTA_uchar orig_image = _texture->get_ram_image();
     if (orig_image.empty()) {

panda/src/dxgsg7/dxTextureContext7.h

@@ -51,8 +51,8 @@ public:
   DWORD _PixBufConversionType;  // enum ConversionType
 
   // must be public since called from global callback fns
-  void DeleteTexture(void);
-  HRESULT FillDDSurfTexturePixels(void);
+  void DeleteTexture();
+  HRESULT FillDDSurfTexturePixels();
 
 protected:
     unsigned int get_bits_per_pixel(Texture::Format format, int *alphbits);

panda/src/dxgsg7/wdxGraphicsWindow7.cxx

@@ -135,7 +135,7 @@ wdxGraphicsWindow7::
 }
 
 void wdxGraphicsWindow7::
-make_current(void) {
+make_current() {
   PStatTimer timer(_make_current_pcollector);
 
   DXGraphicsStateGuardian7 *dxgsg;
@@ -158,7 +158,7 @@ make_current(void) {
 //               opened, or false if there was a problem.
 ////////////////////////////////////////////////////////////////////
 bool wdxGraphicsWindow7::
-open_window(void) {
+open_window() {
 
   if (!choose_device(0, NULL)) {
     wdxdisplay7_cat.error() << "Unable to find suitable rendering device.\n";

panda/src/dxgsg7/wdxGraphicsWindow7.h

@@ -47,8 +47,8 @@ public:
   virtual ~wdxGraphicsWindow7();
   virtual void end_flip();
   //virtual bool begin_frame();
-  virtual void make_current(void);
-  virtual bool open_window(void);
+  virtual void make_current();
+  virtual bool open_window();
 
 protected:
   virtual void fullscreen_restored(WindowProperties &properties);

panda/src/dxgsg8/dxGraphicsDevice8.h

@@ -44,9 +44,9 @@ public:
 
 #if 0
 protected:
-  static TypeHandle get_class_type(void);
-  static void init_type(void);
-  virtual TypeHandle get_type(void) const;
+  static TypeHandle get_class_type();
+  static void init_type();
+  virtual TypeHandle get_type() const;
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
 #endif
 };

panda/src/dxgsg8/dxGraphicsStateGuardian8.h

@@ -131,7 +131,7 @@ protected:
   virtual void set_blend_mode();
 
   void free_nondx_resources();
-  void free_d3d_device(void);
+  void free_d3d_device();
 
   void set_draw_buffer(const RenderBuffer &rb);
   void set_read_buffer(const RenderBuffer &rb);

panda/src/dxgsg8/dxInput8.cxx

@@ -59,7 +59,7 @@ DInput8Info::~DInput8Info() {
   }
 }
 
-bool DInput8Info::InitDirectInput(void) {
+bool DInput8Info::InitDirectInput() {
     HRESULT hr;
 
     // assumes dx8 exists

panda/src/dxgsg8/dxInput8.h

@@ -26,9 +26,9 @@ typedef vector<DIDEVICEOBJECTINSTANCE> DI_DeviceObjInfos;
 
 class DInput8Info {
 public:
- DInput8Info(void);
- ~DInput8Info(void);
- bool InitDirectInput(void);
+ DInput8Info();
+ ~DInput8Info();
+ bool InitDirectInput();
  bool CreateJoystickOrPad(HWND _window);
  bool ReadJoystick(int devnum, DIJOYSTATE2 &js);
 

panda/src/dxgsg8/dxgsg8base.h

@@ -211,7 +211,7 @@ struct DXScreenData {
 
 //utility stuff
 extern pmap<D3DFORMAT_FLAG,D3DFORMAT> g_D3DFORMATmap;
-extern void Init_D3DFORMAT_map(void);
+extern void Init_D3DFORMAT_map();
 extern const char *D3DFormatStr(D3DFORMAT fmt);
 
 #endif

panda/src/dxgsg8/wdxGraphicsPipe8.cxx

@@ -772,7 +772,7 @@ make_gsg(const FrameBufferProperties &properties,
 
 pmap<D3DFORMAT_FLAG, D3DFORMAT> g_D3DFORMATmap;
 
-void Init_D3DFORMAT_map(void) {
+void Init_D3DFORMAT_map() {
   if (g_D3DFORMATmap.size() != 0)
     return;
 

panda/src/dxgsg9/d3dfont9.h

@@ -98,9 +98,9 @@ public:
 
     // Initializing and destroying device-dependent objects
     HRESULT InitDeviceObjects(LPDIRECT3DDEVICE9 pd3dDevice);
-    HRESULT RestoreDeviceObjects(void);
-    HRESULT InvalidateDeviceObjects(void);
-    HRESULT DeleteDeviceObjects(void);
+    HRESULT RestoreDeviceObjects();
+    HRESULT InvalidateDeviceObjects();
+    HRESULT DeleteDeviceObjects();
 
     // Constructor / destructor
     CD3DFont( TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags=0L );

panda/src/dxgsg9/dxGraphicsDevice9.h

@@ -44,9 +44,9 @@ public:
 
 #if 0
 protected:
-  static TypeHandle get_class_type(void);
-  static void init_type(void);
-  virtual TypeHandle get_type(void) const;
+  static TypeHandle get_class_type();
+  static void init_type();
+  virtual TypeHandle get_type() const;
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
 #endif
 };

panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx

@@ -149,7 +149,7 @@ void INLINE TestDrawPrimFailure(DP_Type dptype,HRESULT hr,IDirect3DDevice9 *pD3D
 #endif
 
 void DXGraphicsStateGuardian9::
-reset_panda_gsg(void) {
+reset_panda_gsg() {
     GraphicsStateGuardian::reset();
 
     _auto_rescale_normal = false;
@@ -244,7 +244,7 @@ reset() {
 
 // setup up for re-calling dx_init(), this is not the final exit cleanup routine (see dx_cleanup)
 void DXGraphicsStateGuardian9::
-free_d3d_device(void) {
+free_d3d_device() {
     // dont want a full reset of gsg, just a state clear
     set_state(RenderState::make_empty());
     // want gsg to pass all state settings through
@@ -286,7 +286,7 @@ free_nondx_resources() {
 //               set up.
 ////////////////////////////////////////////////////////////////////
 void DXGraphicsStateGuardian9::
-dx_init(void) {
+dx_init() {
     HRESULT hr;
 
     // make sure gsg passes all current state down to us
@@ -2900,7 +2900,7 @@ framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr, const Rend
     return false;
   }
   
-  (void) ConvertD3DSurftoPixBuf(SrcCopyRect,pD3DSurf,tex);
+  () ConvertD3DSurftoPixBuf(SrcCopyRect,pD3DSurf,tex);
   
   RELEASE(pD3DSurf,dxgsg9,"pD3DSurf",RELEASE_ONCE);
   
@@ -3935,15 +3935,15 @@ set_blend_mode() {
   enable_blend(false);
 }
 
-TypeHandle DXGraphicsStateGuardian9::get_type(void) const {
+TypeHandle DXGraphicsStateGuardian9::get_type() const {
     return get_class_type();
 }
 
-TypeHandle DXGraphicsStateGuardian9::get_class_type(void) {
+TypeHandle DXGraphicsStateGuardian9::get_class_type() {
     return _type_handle;
 }
 
-void DXGraphicsStateGuardian9::init_type(void) {
+void DXGraphicsStateGuardian9::init_type() {
     GraphicsStateGuardian::init_type();
     register_type(_type_handle, "DXGraphicsStateGuardian9",
                   GraphicsStateGuardian::get_class_type());
@@ -4068,7 +4068,7 @@ bool recreate_tex_callback(TextureContext *tc,void *void_dxgsg_ptr) {
 }
 
 // release all textures and vertex/index buffers
-HRESULT DXGraphicsStateGuardian9::DeleteAllDeviceObjects(void) {
+HRESULT DXGraphicsStateGuardian9::DeleteAllDeviceObjects() {
   // BUGBUG: need to release any vertexbuffers here
 
   // cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
@@ -4087,7 +4087,7 @@ HRESULT DXGraphicsStateGuardian9::DeleteAllDeviceObjects(void) {
 }
 
 // recreate all textures and vertex/index buffers
-HRESULT DXGraphicsStateGuardian9::RecreateAllDeviceObjects(void) {
+HRESULT DXGraphicsStateGuardian9::RecreateAllDeviceObjects() {
   // BUGBUG: need to handle vertexbuffer handling here
 
   // cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
@@ -4098,7 +4098,7 @@ HRESULT DXGraphicsStateGuardian9::RecreateAllDeviceObjects(void) {
   return S_OK;
 }
 
-HRESULT DXGraphicsStateGuardian9::ReleaseAllDeviceObjects(void) {
+HRESULT DXGraphicsStateGuardian9::ReleaseAllDeviceObjects() {
     // release any D3DPOOL_DEFAULT objects here (currently none)
     return S_OK;
 }

panda/src/dxgsg9/dxGraphicsStateGuardian9.h

@@ -128,7 +128,7 @@ public:
   virtual void end_scene();
   virtual void end_frame();
 
-  virtual bool wants_texcoords(void) const;
+  virtual bool wants_texcoords() const;
 
   virtual void set_color_clear_value(const Colorf& value);
 
@@ -151,7 +151,7 @@ protected:
   virtual void set_blend_mode();
 
   void free_nondx_resources();            // free local internal buffers
-  void free_d3d_device(void);
+  void free_d3d_device();
 
   void set_draw_buffer(const RenderBuffer &rb);
   void set_read_buffer(const RenderBuffer &rb);
@@ -175,9 +175,9 @@ protected:
                     D3DXVECTOR3 *pCenter, float fRadius,
                     DWORD wNumRings, DWORD wNumSections, float sx, float sy, float sz,
                     DWORD *pNumVertices,DWORD *pNumTris,DWORD fvfFlags,DWORD dwVertSize);
-  HRESULT ReleaseAllDeviceObjects(void);
-  HRESULT RecreateAllDeviceObjects(void);
-  HRESULT DeleteAllDeviceObjects(void);
+  HRESULT ReleaseAllDeviceObjects();
+  HRESULT RecreateAllDeviceObjects();
+  HRESULT DeleteAllDeviceObjects();
 
 /*
   INLINE void enable_multisample_alpha_one(bool val);
@@ -323,23 +323,23 @@ public:
   void set_context(DXScreenData *pNewContextData);
   void set_render_target();
 
-  static TypeHandle get_class_type(void);
-  static void init_type(void);
-  virtual TypeHandle get_type(void) const;
+  static TypeHandle get_class_type();
+  static void init_type();
+  virtual TypeHandle get_type() const;
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
   INLINE void SetDXReady(bool status)  { _bDXisReady = status; }
-  INLINE bool GetDXReady(void)  { return _bDXisReady;}
+  INLINE bool GetDXReady()  { return _bDXisReady;}
   void DXGraphicsStateGuardian9::SetTextureBlendMode(TextureStage::Mode TexBlendMode,bool bJustEnable);
 
   void  dx_cleanup(bool bRestoreDisplayMode,bool bAtExitFnCalled);
-  void reset_panda_gsg(void);
+  void reset_panda_gsg();
   HRESULT reset_d3d_device(D3DPRESENT_PARAMETERS *pPresParams, DXScreenData **pScrn=NULL);
 
   #define DO_REACTIVATE_WINDOW true
   bool CheckCooperativeLevel(bool bDoReactivateWindow = false);
 
   void show_frame(bool bNoNewFrameDrawn = false);
-  void dx_init(void);
+  void dx_init();
 
   void support_overlay_window(bool flag);
 

panda/src/dxgsg9/dxInput9.cxx

@@ -59,7 +59,7 @@ DInput9Info::~DInput9Info() {
   }
 }
 
-bool DInput9Info::InitDirectInput(void) {
+bool DInput9Info::InitDirectInput() {
     HRESULT hr;
 
     // assumes dx9 exists

panda/src/dxgsg9/dxInput9.h

@@ -26,9 +26,9 @@ typedef vector<DIDEVICEOBJECTINSTANCE> DI_DeviceObjInfos;
 
 class DInput9Info {
 public:
- DInput9Info(void);
- ~DInput9Info(void);
- bool InitDirectInput(void);
+ DInput9Info();
+ ~DInput9Info();
+ bool InitDirectInput();
  bool CreateJoystickOrPad(HWND hWnd);
  bool ReadJoystick(int devnum, DIJOYSTATE2 &js);
 

panda/src/dxgsg9/dxTextureContext9.cxx

@@ -930,7 +930,7 @@ IDirect3DTexture9 *DXTextureContext9::CreateTexture(DXScreenData &scrn) {
 }
 
 HRESULT DXTextureContext9::
-FillDDSurfTexturePixels(void) {
+FillDDSurfTexturePixels() {
     HRESULT hr=E_FAIL;
     assert(IS_VALID_PTR(_texture));
 

panda/src/dxgsg9/dxTextureContext9.h

@@ -50,8 +50,8 @@ public:
 #endif
 
   // must be public since called from global callback fns
-  void DeleteTexture(void);
-  HRESULT FillDDSurfTexturePixels(void);
+  void DeleteTexture();
+  HRESULT FillDDSurfTexturePixels();
 
 protected:
     unsigned int get_bits_per_pixel(Texture::Format format, int *alphbits);

panda/src/dxgsg9/dxgsg9base.h

@@ -215,7 +215,7 @@ typedef struct {
 
 //utility stuff
 extern map<D3DFORMAT_FLAG,D3DFORMAT> g_D3DFORMATmap;
-extern void Init_D3DFORMAT_map(void);
+extern void Init_D3DFORMAT_map();
 extern const char *D3DFormatStr(D3DFORMAT fmt);
 
 #endif

panda/src/dxgsg9/wdxGraphicsPipe9.cxx

@@ -876,7 +876,7 @@ make_gsg(const FrameBufferProperties &properties,
 
 map<D3DFORMAT_FLAG,D3DFORMAT> g_D3DFORMATmap;
 
-void Init_D3DFORMAT_map(void) {
+void Init_D3DFORMAT_map() {
   if(g_D3DFORMATmap.size()!=0)
     return;
 

panda/src/dxgsg9/wdxGraphicsWindow9.cxx

@@ -95,7 +95,7 @@ wdxGraphicsWindow9::
 }
 
 void wdxGraphicsWindow9::
-make_current(void) {
+make_current() {
   PStatTimer timer(_make_current_pcollector);
 
   DXGraphicsStateGuardian9 *dxgsg;
@@ -115,7 +115,7 @@ make_current(void) {
 /* BUGBUG:  need to reinstate these methods ASAP.  they were incorrectly moved from the GraphicsWindow to the GSG
             apps need to know the framebuffer format so they can create texture/rendertgt with same fmt
 int wdxGraphicsWindow9::
-get_depth_bitwidth(void) {
+get_depth_bitwidth() {
     assert(_dxgsg!=NULL);
     if(_dxgsg->scrn.PresParams.EnableAutoDepthStencil)
        return _dxgsg->scrn.depth_buffer_bitdepth;
@@ -906,7 +906,7 @@ create_screen_buffers_and_device(DXScreenData &Display, bool force_16bpp_zbuffer
 //               Returns true if successful, false on failure.
 ////////////////////////////////////////////////////////////////////
 bool wdxGraphicsWindow9::
-choose_device(void) {
+choose_device() {
   HRESULT hr;
 
   wdxGraphicsPipe9 *dxpipe;
@@ -1003,7 +1003,7 @@ choose_device(void) {
 
 /*
 primary init sequence of old method, still need to integrate multi-window functionality
-void wdxGraphicsWindow9Group::initWindowGroup(void) {
+void wdxGraphicsWindow9Group::initWindowGroup() {
     HRESULT hr;
 
     assert(_windows.size()>0);
@@ -1740,7 +1740,7 @@ reset_window(bool swapchain) {
 //               opened, or false if there was a problem.
 ////////////////////////////////////////////////////////////////////
 bool wdxGraphicsWindow9::
-open_window(void) {
+open_window() {
   PT(DXGraphicsDevice9) dxdev;
   DXGraphicsStateGuardian9 *dxgsg;
   DCAST_INTO_R(dxgsg,_gsg,false);
@@ -1813,6 +1813,6 @@ open_window(void) {
 
 bool wdxGraphicsWindow9::
 handle_mouse_motion(int x, int y) {
-  (void) WinGraphicsWindow::handle_mouse_motion(x,y);
+  () WinGraphicsWindow::handle_mouse_motion(x,y);
   return false;
 }

panda/src/dxgsg9/wdxGraphicsWindow9.h

@@ -42,8 +42,8 @@ public:
   wdxGraphicsWindow9(GraphicsPipe *pipe, GraphicsStateGuardian *gsg,
                      const string &name);
   virtual ~wdxGraphicsWindow9();
-  virtual bool open_window(void);
-  virtual void close_window(void);
+  virtual bool open_window();
+  virtual void close_window();
   virtual void reset_window(bool swapchain);
 
   virtual int verify_window_sizes(int numsizes, int *dimen);
@@ -64,7 +64,7 @@ private:
   bool create_screen_buffers_and_device(DXScreenData &Display,
                                         bool force_16bpp_zbuffer);
 
-  bool choose_device(void);
+  bool choose_device();
   bool search_for_device(wdxGraphicsPipe9 *dxpipe, DXDeviceInfo *device_info);
 
   //  void set_coop_levels_and_display_modes();
@@ -100,7 +100,7 @@ public:
     return get_class_type();
   }
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
-  virtual void make_current(void);
+  virtual void make_current();
 
 private:
   static TypeHandle _type_handle;

panda/src/effects/lensFlareNode.I

@@ -22,7 +22,7 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE LensFlareNode::
-LensFlareNode(void) :
+LensFlareNode() :
   _global_scale(1), _texel_scale(0.1), _blind_fall_off(45), _flare_fall_off(5)
 {
   _blind = (Texture *)NULL;

panda/src/effects/lensFlareNode.cxx

@@ -573,7 +573,7 @@ register_with_read_factory() {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 LensFlareNode::
-LensFlareNode(void) :
+LensFlareNode() :
   _global_scale(1), _next_switch(-1), _sparkle_fps(0.2),
   _texel_scale(0.1), _inv_sparkle_fps(5), _exp_scale(15)
 {

panda/src/effects/lensFlareNode.h

@@ -37,7 +37,7 @@ class ClockObject;
 class EXPCL_PANDAFX LensFlareNode : public Node
 {
 PUBLISHED:
-  INLINE LensFlareNode(void);
+  INLINE LensFlareNode();
 
   void add_flare(PT(Texture) flare, PTA_float scales, PTA_float offsets,
                  PTA_float angle_scales, PTA_Colorf colors);

panda/src/egg/eggData.cxx

@@ -30,7 +30,7 @@
 #include "dSearchPath.h"
 #include "virtualFileSystem.h"
 
-extern int eggyyparse(void);
+extern int eggyyparse();
 #include "parserDefs.h"
 #include "lexerDefs.h"
 

panda/src/egg/eggNode.cxx

@@ -24,7 +24,7 @@
 
 #include <algorithm>
 
-extern int eggyyparse(void);
+extern int eggyyparse();
 #include "parserDefs.h"
 #include "lexerDefs.h"
 

panda/src/express/buffer.I

@@ -22,6 +22,6 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE int Buffer::
-get_length(void) const {
+get_length() const {
   return _length;
 }

panda/src/express/buffer.h

@@ -33,7 +33,7 @@ public:
   ~Buffer();
 
 PUBLISHED:
-  INLINE int get_length(void) const;
+  INLINE int get_length() const;
 
 #ifndef CPPPARSER
 // hidden from interrogate

panda/src/express/datagramGenerator.I

@@ -24,6 +24,6 @@
 //               the definition of an interface
 ////////////////////////////////////////////////////////////////////
 
-INLINE DatagramGenerator::DatagramGenerator(void){
+INLINE DatagramGenerator::DatagramGenerator(){
 }
 

panda/src/express/datagramSink.I

@@ -24,5 +24,5 @@
 //               the definition of an interface
 ////////////////////////////////////////////////////////////////////
 
-INLINE DatagramSink::DatagramSink(void){
+INLINE DatagramSink::DatagramSink(){
 }

panda/src/express/datagramSink.cxx

@@ -24,5 +24,5 @@
 //  Description: Does nothing since this is class is just
 //               the definition of an interface
 ////////////////////////////////////////////////////////////////////
-DatagramSink::~DatagramSink(void){
+DatagramSink::~DatagramSink(){
 }

panda/src/express/datagramSink.h

@@ -31,8 +31,8 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDAEXPRESS DatagramSink {
 public:
-  INLINE DatagramSink(void);
-  virtual ~DatagramSink(void);
+  INLINE DatagramSink();
+  virtual ~DatagramSink();
 
   virtual bool put_datagram(const Datagram &data) = 0;
   virtual bool is_error() = 0;

panda/src/express/encryptStreamBuf.h

@@ -53,8 +53,8 @@ public:
 
 protected:
   virtual int overflow(int c);
-  virtual int sync(void);
-  virtual int underflow(void);
+  virtual int sync();
+  virtual int underflow();
 
 private:
   size_t read_chars(char *start, size_t length);

panda/src/express/error_utils.cxx

@@ -158,7 +158,7 @@ string error_to_text(ErrorUtilCode err) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 int
-get_write_error(void) {
+get_write_error() {
 #ifndef WIN32
   return EU_error_abort;
 #else
@@ -195,7 +195,7 @@ get_write_error(void) {
 //     Function: handle_socket_error
 //  Description:
 ////////////////////////////////////////////////////////////////////
-string handle_socket_error(void) {
+string handle_socket_error() {
 #ifndef WIN32
   return string(strerror(errno));
 #else
@@ -255,7 +255,7 @@ string handle_socket_error(void) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 int
-get_network_error(void) {
+get_network_error() {
 #ifndef WIN32
   return EU_error_abort;
 #else

panda/src/express/error_utils.h

@@ -80,11 +80,11 @@ enum ErrorUtilCode {
 };
 
 EXPCL_PANDAEXPRESS string error_to_text(ErrorUtilCode err);
-EXPCL_PANDAEXPRESS int get_write_error(void);
+EXPCL_PANDAEXPRESS int get_write_error();
 
 #ifdef HAVE_NET
-EXPCL_PANDAEXPRESS string handle_socket_error(void);
-EXPCL_PANDAEXPRESS int get_network_error(void);
+EXPCL_PANDAEXPRESS string handle_socket_error();
+EXPCL_PANDAEXPRESS int get_network_error();
 #endif
 
 END_PUBLISH

panda/src/express/patchfile.I

@@ -24,7 +24,7 @@
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE float Patchfile::
-get_progress(void) const {
+get_progress() const {
   if (false == _initiated) {
     express_cat.warning()
       << "Patchfile::get_progress() - Patch has not been initiated" << endl;

panda/src/express/patchfile.cxx

@@ -107,7 +107,7 @@ const PN_uint32 Patchfile::_HASH_MASK = (PN_uint32(1) << Patchfile::_HASH_BITS)
 //  Description:
 ////////////////////////////////////////////////////////////////////
 Patchfile::
-Patchfile(void) {
+Patchfile() {
   PT(Buffer) buffer = new Buffer(patchfile_buffer_size);
   init(buffer);
 }
@@ -144,7 +144,7 @@ init(PT(Buffer) buffer) {
 //  Description:
 ////////////////////////////////////////////////////////////////////
 Patchfile::
-~Patchfile(void) {
+~Patchfile() {
   if (true == _initiated)
     cleanup();
 }
@@ -155,7 +155,7 @@ Patchfile::
 //  Description:
 ////////////////////////////////////////////////////////////////////
 void Patchfile::
-cleanup(void) {
+cleanup() {
   if (false == _initiated) {
     express_cat.error()
       << "Patchfile::cleanup() - Patching has not been initiated"
@@ -268,7 +268,7 @@ read_header(const Filename &patch_file) {
 //  Description: Perform one buffer's worth of patching
 ////////////////////////////////////////////////////////////////////
 int Patchfile::
-run(void) {
+run() {
   // Now patch the file using the given buffer
   int buflen;
   int bytes_read;

panda/src/express/patchfile.h

@@ -53,19 +53,19 @@ PUBLISHED:
   };
   */
 
-  Patchfile(void);
+  Patchfile();
   Patchfile(PT(Buffer) buffer);
-  ~Patchfile(void);
+  ~Patchfile();
 
   bool build(Filename file_orig, Filename file_new, Filename patch_name);
   int read_header(const Filename &patch_file);
 
   int initiate(const Filename &patch_file, const Filename &file);
-  int run(void);
+  int run();
 
   bool apply(Filename &patch_file, Filename &file);
 
-  INLINE float get_progress(void) const;
+  INLINE float get_progress() const;
 
   INLINE void set_footprint_length(int length);
   INLINE int get_footprint_length();
@@ -78,7 +78,7 @@ PUBLISHED:
 private:
   int internal_read_header(const Filename &patch_file);
   void init(PT(Buffer) buffer);
-  void cleanup(void);
+  void cleanup();
 
 private:
   // stuff for the build operation

panda/src/express/subStreamBuf.h

@@ -38,8 +38,8 @@ public:
 
 protected:
   virtual int overflow(int c);
-  virtual int sync(void);
-  virtual int underflow(void);
+  virtual int sync();
+  virtual int underflow();
 
 private:
   istream *_source;

panda/src/express/test_types.cxx

@@ -45,7 +45,7 @@ public:
   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();
   }
@@ -74,7 +74,7 @@ public:
   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();
   }
@@ -101,7 +101,7 @@ public:
   static void init_type() {
     register_type(_type_handle, "TheOtherThingie");
   }
-  virtual TypeHandle force_init_type(void) {
+  virtual TypeHandle force_init_type() {
     init_type();
     return get_class_type();
   }
@@ -137,7 +137,7 @@ public:
   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/express/zStreamBuf.h

@@ -44,8 +44,8 @@ public:
 
 protected:
   virtual int overflow(int c);
-  virtual int sync(void);
-  virtual int underflow(void);
+  virtual int sync();
+  virtual int underflow();
 
 private:
   size_t read_chars(char *start, size_t length);

panda/src/glstuff/glGraphicsStateGuardian_src.h

@@ -150,13 +150,13 @@ public:
   virtual void bind_light(Spotlight *light_obj, const NodePath &light, 
                           int light_id);
 
-  virtual bool wants_texcoords(void) const;
+  virtual bool wants_texcoords() const;
 
   void print_gfx_visual();
 
   //For those interested in what the guardian thinks is the current
   //enabled/disable GL State compared to what GL says it is
-  void dump_state(void);
+  void dump_state();
 
   const float *get_light_color(Light *light) const;
 

panda/src/glstuff/glShaderContext_src.I

@@ -31,7 +31,7 @@ bind(ShaderMode *m) {
 //  Description: xyz
 ////////////////////////////////////////////////////////////////////
 INLINE void CLP(ShaderContext)::
-unbind(void) {
+unbind() {
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/glstuff/glShaderContext_src.cxx

@@ -38,6 +38,6 @@ CLP(ShaderContext)(Shader *s) : ShaderContext(s) {
 //  Description: xyz
 ////////////////////////////////////////////////////////////////////
 CLP(ShaderContext)::
-~CLP(ShaderContext)(void) {
+~CLP(ShaderContext)() {
 }
 

panda/src/glstuff/glShaderContext_src.h

@@ -27,10 +27,10 @@
 class EXPCL_GL CLP(ShaderContext): public ShaderContext {
 public:
   CLP(ShaderContext)(Shader *shader);
-  ~CLP(ShaderContext)(void);
+  ~CLP(ShaderContext)();
 
   INLINE void bind(ShaderMode *mode);
-  INLINE void unbind(void);
+  INLINE void unbind();
   INLINE void rebind(ShaderMode *oldmode, ShaderMode *newmode);
 
 public:

panda/src/glxdisplay/glxext.h

@@ -301,11 +301,11 @@ extern "C" {
    on my redhat 8.0 box).  So we work around this by typedeffing it
    explicitly; and we use #define in case it is already typedeffed. */
 #define __GLXextFuncPtr panda__GLXextFuncPtr
-typedef void (*__GLXextFuncPtr)(void);
+typedef void (*__GLXextFuncPtr)();
 
   /*
 #ifndef GLX_ARB_get_proc_address
-typedef void (*__GLXextFuncPtr)(void);
+typedef void (*__GLXextFuncPtr)();
 #endif
   */
 
@@ -358,8 +358,8 @@ extern void glXDestroyPbuffer (Display *, GLXPbuffer);
 extern void glXQueryDrawable (Display *, GLXDrawable, int, unsigned int *);
 extern GLXContext glXCreateNewContext (Display *, GLXFBConfig, int, GLXContext, Bool);
 extern Bool glXMakeContextCurrent (Display *, GLXDrawable, GLXDrawable, GLXContext);
-extern GLXDrawable glXGetCurrentReadDrawable (void);
-extern Display * glXGetCurrentDisplay (void);
+extern GLXDrawable glXGetCurrentReadDrawable ();
+extern Display * glXGetCurrentDisplay ();
 extern int glXQueryContext (Display *, GLXContext, int, int *);
 extern void glXSelectEvent (Display *, GLXDrawable, unsigned long);
 extern void glXGetSelectedEvent (Display *, GLXDrawable, unsigned long *);
@@ -379,8 +379,8 @@ typedef void (* PFNGLXDESTROYPBUFFERPROC) (Display *dpy, GLXPbuffer pbuf);
 typedef void (* PFNGLXQUERYDRAWABLEPROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
 typedef GLXContext (* PFNGLXCREATENEWCONTEXTPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
 typedef Bool (* PFNGLXMAKECONTEXTCURRENTPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-typedef GLXDrawable (* PFNGLXGETCURRENTREADDRAWABLEPROC) (void);
-typedef Display * (* PFNGLXGETCURRENTDISPLAYPROC) (void);
+typedef GLXDrawable (* PFNGLXGETCURRENTREADDRAWABLEPROC) ();
+typedef Display * (* PFNGLXGETCURRENTDISPLAYPROC) ();
 typedef int (* PFNGLXQUERYCONTEXTPROC) (Display *dpy, GLXContext ctx, int attribute, int *value);
 typedef void (* PFNGLXSELECTEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask);
 typedef void (* PFNGLXGETSELECTEDEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
@@ -436,10 +436,10 @@ typedef int (* PFNGLXWAITVIDEOSYNCSGIPROC) (int divisor, int remainder, unsigned
 #define GLX_SGI_make_current_read 1
 #ifdef GLX_GLXEXT_PROTOTYPES
 extern Bool glXMakeCurrentReadSGI (Display *, GLXDrawable, GLXDrawable, GLXContext);
-extern GLXDrawable glXGetCurrentReadDrawableSGI (void);
+extern GLXDrawable glXGetCurrentReadDrawableSGI ();
 #endif /* GLX_GLXEXT_PROTOTYPES */
 typedef Bool (* PFNGLXMAKECURRENTREADSGIPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-typedef GLXDrawable (* PFNGLXGETCURRENTREADDRAWABLESGIPROC) (void);
+typedef GLXDrawable (* PFNGLXGETCURRENTREADDRAWABLESGIPROC) ();
 #endif
 
 #ifndef GLX_SGIX_video_source
@@ -461,13 +461,13 @@ typedef void (* PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC) (Display *dpy, GLXVideoSour
 #ifndef GLX_EXT_import_context
 #define GLX_EXT_import_context 1
 #ifdef GLX_GLXEXT_PROTOTYPES
-extern Display * glXGetCurrentDisplayEXT (void);
+extern Display * glXGetCurrentDisplayEXT ();
 extern int glXQueryContextInfoEXT (Display *, GLXContext, int, int *);
 extern GLXContextID glXGetContextIDEXT (const GLXContext);
 extern GLXContext glXImportContextEXT (Display *, GLXContextID);
 extern void glXFreeContextEXT (Display *, GLXContext);
 #endif /* GLX_GLXEXT_PROTOTYPES */
-typedef Display * (* PFNGLXGETCURRENTDISPLAYEXTPROC) (void);
+typedef Display * (* PFNGLXGETCURRENTDISPLAYEXTPROC) ();
 typedef int (* PFNGLXQUERYCONTEXTINFOEXTPROC) (Display *dpy, GLXContext context, int attribute, int *value);
 typedef GLXContextID (* PFNGLXGETCONTEXTIDEXTPROC) (const GLXContext context);
 typedef GLXContext (* PFNGLXIMPORTCONTEXTEXTPROC) (Display *dpy, GLXContextID contextID);

panda/src/gobj/shader.I

@@ -22,7 +22,7 @@
 //  Description: Return the shader's text.
 ////////////////////////////////////////////////////////////////////
 INLINE const string &Shader::
-get_text(void) {
+get_text() {
   return _text;
 }
 
@@ -32,7 +32,7 @@ get_text(void) {
 //  Description: Return the shader's filename, or null string.
 ////////////////////////////////////////////////////////////////////
 INLINE const Filename &Shader::
-get_file(void) {
+get_file() {
   return _file;
 }
 

panda/src/gobj/shader.cxx

@@ -48,7 +48,7 @@ Shader::
 //  Description: Set a 'parse pointer' to the beginning of the shader.
 ////////////////////////////////////////////////////////////////////
 void Shader::
-parse_init(void) {
+parse_init() {
   _parse = 0;
 }
 
@@ -121,7 +121,7 @@ parse_rest(string &result) {
 //               the shader.
 ////////////////////////////////////////////////////////////////////
 bool Shader::
-parse_eof(void) {
+parse_eof() {
   return (int)_text.size() == _parse;
 }
 

panda/src/gobj/shader.h

@@ -51,24 +51,24 @@ class EXPCL_PANDA Shader: public TypedWritableReferenceCount {
 
 PUBLISHED:
   Shader(const string &text, const string &file);
-  ~Shader(void);
+  ~Shader();
 
-  INLINE const string   &get_text(void);
-  INLINE const Filename &get_file(void);
+  INLINE const string   &get_text();
+  INLINE const Filename &get_file();
   
   void prepare(PreparedGraphicsObjects *prepared_objects);
   bool release(PreparedGraphicsObjects *prepared_objects);
   int release_all();
 
 PUBLISHED:
-  void parse_init(void);
+  void parse_init();
   void parse_line(string &result, bool rt, bool lt);
   void parse_upto(string &result, string pattern, bool include);
   void parse_rest(string &result);
-  bool parse_eof(void);
+  bool parse_eof();
 
 public:
-  INLINE int arg_count(void);
+  INLINE int arg_count();
   int        arg_index(const string &id);
 
   string         _text;
@@ -79,7 +79,7 @@ public:
   typedef pmap<PreparedGraphicsObjects *, ShaderContext *> Contexts;
   Contexts _contexts;
 
-  static void register_with_read_factory(void);
+  static void register_with_read_factory();
 
   friend class ShaderContext;
   friend class PreparedGraphicsObjects;
@@ -88,7 +88,7 @@ public:
                              GraphicsStateGuardianBase *gsg);
 
 private:  
-  void parse(void);
+  void parse();
   void clear_prepared(PreparedGraphicsObjects *prepared_objects);
 
 public: