TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

(void) -> ()

Browse Source
This commit is contained in:
David Rose 2005-09-06 20:16:09 +00:00
parent 9d9cd8e07b
commit 292b0d1d95
161 changed files with 532 additions and 532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
panda/src/chan/animBundle.I
View File

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

2
panda/src/chan/animBundle.cxx
View File

@ -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);
}

4
panda/src/chan/animBundle.h
View File

@ -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);

2
panda/src/chan/animChannelMatrixXfmTable.h
View File

@ -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);

4
panda/src/chan/animChannelScalarTable.cxx
View File

@ -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);
}

4
panda/src/chan/animChannelScalarTable.h
View File

@ -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);

2
panda/src/chan/animGroup.cxx
View File

@ -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);
}

2
panda/src/chan/animGroup.h
View File

@ -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);

2
panda/src/chan/movingPart.I
View File

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

2
panda/src/chan/movingPart.h
View File

@ -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:

2
panda/src/chan/movingPartBase.cxx
View File

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

2
panda/src/chan/movingPartBase.h
View File

@ -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);

2
panda/src/chan/movingPartMatrix.I
View File

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

2
panda/src/chan/movingPartMatrix.cxx
View File

@ -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);
}

4
panda/src/chan/movingPartMatrix.h
View File

@ -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);

2
panda/src/chan/movingPartScalar.I
View File

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

2
panda/src/chan/movingPartScalar.cxx
View File

@ -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);
}

4
panda/src/chan/movingPartScalar.h
View File

@ -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);

2
panda/src/chan/partBundle.cxx
View File

@ -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);
}

2
panda/src/chan/partBundle.h
View File

@ -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);

2
panda/src/chan/partGroup.cxx
View File

@ -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);
}

2
panda/src/chan/partGroup.h
View File

@ -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);

2
panda/src/char/characterJoint.cxx
View File

@ -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);
}

2
panda/src/char/characterJoint.h
View File

@ -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);

2
panda/src/char/characterJointBundle.cxx
View File

@ -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);
}

2
panda/src/char/characterJointBundle.h
View File

@ -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);

2
panda/src/char/characterSlider.cxx
View File

@ -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);
}

6
panda/src/collide/collisionNode.h
View File

@ -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();}

2
panda/src/collide/collisionPlane.cxx
View File

@ -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);
}

2
panda/src/collide/collisionPlane.h
View File

@ -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);

2
panda/src/collide/collisionPolygon.h
View File

@ -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);

2
panda/src/display/graphicsStateGuardian.I
View File

@ -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;
}

2
panda/src/display/graphicsStateGuardian.h
View File

@ -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);

4
panda/src/doc/particle_system_parameters.txt
View File

@ -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:

2
panda/src/downloader/asyncUtility.I
View File

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

8
panda/src/downloader/asyncUtility.cxx
View File

@ -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));

14
panda/src/downloader/asyncUtility.h
View File

@ -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;

4
panda/src/downloader/bioStreamBuf.h
View File

@ -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);

2
panda/src/downloader/chunkedStreamBuf.h
View File

@ -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);

2
panda/src/downloader/decompressor.h
View File

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

4
panda/src/downloader/downloadDb.I
View File

@ -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();
}

16
panda/src/downloader/downloadDb.cxx
View File

@ -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 = "";
}

18
panda/src/downloader/downloadDb.h
View File

@ -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;

2
panda/src/downloader/extractor.h
View File

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

2
panda/src/downloader/identityStreamBuf.h
View File

@ -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);

2
panda/src/downloader/patcher.I
View File

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

6
panda/src/downloader/patcher.cxx
View File

@ -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();
}

8
panda/src/downloader/patcher.h
View File

@ -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);

22
panda/src/dxgsg7/dxGraphicsStateGuardian7.cxx
View File

@ -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);

20
panda/src/dxgsg7/dxGraphicsStateGuardian7.h
View File

@ -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 );

2
panda/src/dxgsg7/dxTextureContext7.cxx
View File

@ -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()) {

4
panda/src/dxgsg7/dxTextureContext7.h
View File

@ -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);

4
panda/src/dxgsg7/wdxGraphicsWindow7.cxx
View File

@ -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";

4
panda/src/dxgsg7/wdxGraphicsWindow7.h
View File

@ -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);

6
panda/src/dxgsg8/dxGraphicsDevice8.h
View File

@ -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
};

2
panda/src/dxgsg8/dxGraphicsStateGuardian8.h
View File

@ -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);

2
panda/src/dxgsg8/dxInput8.cxx
View File

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

6
panda/src/dxgsg8/dxInput8.h
View File

@ -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);

2
panda/src/dxgsg8/dxgsg8base.h
View File

@ -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

2
panda/src/dxgsg8/wdxGraphicsPipe8.cxx
View File

@ -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;

6
panda/src/dxgsg9/d3dfont9.h
View File

@ -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 );

6
panda/src/dxgsg9/dxGraphicsDevice9.h
View File

@ -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
};

20
panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
View File

@ -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;
}

22
panda/src/dxgsg9/dxGraphicsStateGuardian9.h
View File

@ -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);

2
panda/src/dxgsg9/dxInput9.cxx
View File

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

6
panda/src/dxgsg9/dxInput9.h
View File

@ -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);

2
panda/src/dxgsg9/dxTextureContext9.cxx
View File

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

4
panda/src/dxgsg9/dxTextureContext9.h
View File

@ -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);

2
panda/src/dxgsg9/dxgsg9base.h
View File

@ -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

2
panda/src/dxgsg9/wdxGraphicsPipe9.cxx
View File

@ -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;

12
panda/src/dxgsg9/wdxGraphicsWindow9.cxx
View File

@ -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;
}

8
panda/src/dxgsg9/wdxGraphicsWindow9.h
View File

@ -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;

2
panda/src/effects/lensFlareNode.I
View File

@ -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;

2
panda/src/effects/lensFlareNode.cxx
View File

@ -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)
{

2
panda/src/effects/lensFlareNode.h
View File

@ -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);

2
panda/src/egg/eggData.cxx
View File

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

2
panda/src/egg/eggNode.cxx
View File

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

2
panda/src/express/buffer.I
View File

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

2
panda/src/express/buffer.h
View File

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

2
panda/src/express/datagramGenerator.I
View File

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

2
panda/src/express/datagramSink.I
View File

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

2
panda/src/express/datagramSink.cxx
View File

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

4
panda/src/express/datagramSink.h
View File

@ -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;

4
panda/src/express/encryptStreamBuf.h
View File

@ -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);

6
panda/src/express/error_utils.cxx
View File

@ -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

6
panda/src/express/error_utils.h
View File

@ -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

2
panda/src/express/patchfile.I
View File

@ -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;

8
panda/src/express/patchfile.cxx
View File

@ -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;

10
panda/src/express/patchfile.h
View File

@ -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

4
panda/src/express/subStreamBuf.h
View File

@ -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;

8
panda/src/express/test_types.cxx
View File

@ -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();
}

4
panda/src/express/zStreamBuf.h
View File

@ -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);

4
panda/src/glstuff/glGraphicsStateGuardian_src.h
View File

@ -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;

2
panda/src/glstuff/glShaderContext_src.I
View File

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

2
panda/src/glstuff/glShaderContext_src.cxx
View File

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

4
panda/src/glstuff/glShaderContext_src.h
View File

@ -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:

20
panda/src/glxdisplay/glxext.h
View File

@ -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);

4
panda/src/gobj/shader.I
View File

@ -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;
}

4
panda/src/gobj/shader.cxx
View File

@ -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;
}

16
panda/src/gobj/shader.h
View File

@ -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:

Some files were not shown because too many files have changed in this diff Show More