ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed callback manager, callbacks are not needed the way they were

Browse Source 
with plib, and the track is now updating its animated textures and
physical objects.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/branches/irrlicht@3337 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk 2009-04-01 00:55:20 +00:00
parent 0681523762
commit 30de5e36f8
20 changed files with 46 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/Makefile.am
View File

@ -161,9 +161,6 @@ supertuxkart_SOURCES = \
loader.hpp \
race_manager.cpp \
race_manager.hpp \
callback.hpp \
callback_manager.cpp \
callback_manager.hpp \
main_loop.cpp \
main_loop.hpp \
user_pointer.hpp \

37
src/callback.hpp
View File

@ -1,37 +0,0 @@
// $Id: callback.hpp 796 2006-09-27 07:06:34Z hiker $
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2006 Joerg Henrichs
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef CALLBACK_H
#define CALLBACK_H
#include "btBulletDynamicsCommon.h"
class Callback
{
public:
virtual ~Callback() {};
virtual void update (float dt) = 0;
virtual void init () = 0;
virtual void reset () {};
virtual void handleExplosion(const btVector3& pos, bool directHit) {};
}
; // Callback
#endif

142
src/callback_manager.cpp
View File

@ -1,142 +0,0 @@
// $Id: callback_manager.cpp 796 2006-09-27 07:06:34Z hiker $
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2006 Joerg Henrichs
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "callback_manager.hpp"
#include "physics/moving_physics.hpp"
CallbackManager *callback_manager=NULL;
CallbackManager::CallbackManager()
{
for(int i=0; i<CB_MAX; i++)
{
m_allCallbacks[i].clear();
}
} // CallbackManager
//-----------------------------------------------------------------------------
CallbackManager::~CallbackManager()
{
for(int i=0; i<CB_MAX; i++)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[i].begin();
c != m_allCallbacks[i].end(); c++)
{
MovingPhysics *mp = dynamic_cast<MovingPhysics*>(*c);
if(mp)
{
#ifndef HAVE_IRRLICHT
ssgDeRefDelete(mp);
#endif
}
else
{
delete *c;
}
} // for c in m_allCallbacks[i]
m_allCallbacks[i].clear();
} // for i <CB_MAX
} // ~CallbackManager
//-----------------------------------------------------------------------------
void CallbackManager::addCallback(Callback *c, CallbackType t)
{
m_allCallbacks[t].push_back(c);
MovingPhysics *mp = dynamic_cast<MovingPhysics*>(c);
if(mp)
{
#ifndef HAVE_IRRLICHT
mp->ref();
#endif
}
} // addCallback
//-----------------------------------------------------------------------------
void CallbackManager::clear(CallbackType cbType)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[cbType].begin();
c != m_allCallbacks[cbType].end(); c++)
{
MovingPhysics *mp = dynamic_cast<MovingPhysics*>(*c);
if(mp)
{
#ifndef HAVE_IRRLICHT
ssgDeRefDelete(mp);
#endif
}
else
{
delete *c;
}
}
m_allCallbacks[cbType].clear();
} // clear
//-----------------------------------------------------------------------------
void CallbackManager::update(float dt) const
{
for(int i=0; i<CB_MAX; i++)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[i].begin();
c != m_allCallbacks[i].end(); c++)
(*c)->update(dt);
} // for i
} // update
//-----------------------------------------------------------------------------
void CallbackManager::initAll() const
{
for(int i=0; i<CB_MAX; i++)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[i].begin();
c != m_allCallbacks[i].end(); c++)
(*c)->init();
} // for i
} // initAll
//-----------------------------------------------------------------------------
// Called when restarting a race
void CallbackManager::reset() const
{
for(int i=0; i<CB_MAX; i++)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[i].begin();
c != m_allCallbacks[i].end(); c++)
(*c)->reset();
} // for i
} // initAll
//-----------------------------------------------------------------------------
void CallbackManager::handleExplosion(const btVector3& pos,
const MovingPhysics* mp) const
{
for(int i=0; i<CB_MAX; i++)
{
for(std::vector<Callback*>::const_iterator c = m_allCallbacks[i].begin();
c != m_allCallbacks[i].end(); c++)
(*c)->handleExplosion(pos, mp==(*c));
} // for i
} // handleExplosion

57
src/callback_manager.hpp
View File

@ -1,57 +0,0 @@
// $Id: callback_manager.hpp 796 2006-09-27 07:06:34Z hiker $
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2006 Joerg Henrichs
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef CALLBACK_MANAGER_HPP
#define CALLBACK_MANAGER_HPP
#include <vector>
#include "btBulletDynamicsCommon.h"
#include "callback.hpp"
class MovingPhysics;
// It might actually be enough to have only two different values: track (which
// get deleted and loaded more than one), and everything else, which only
// gets loaded once, and deleted at the end (and when switching windows /
// fullscreen). Sinace it's not much overhead, a separate class is provided
// for every model that might contain a callback.
enum CallbackType { CB_COLLECTABLE, CB_ATTACHMENT, CB_EXPLOSION, CB_ITEM,
CB_KART, CB_TRACK, CB_MAX };
class CallbackManager
{
std::vector<Callback*> m_allCallbacks[CB_MAX];
public:
CallbackManager();
~CallbackManager();
void update (float dt) const;
void initAll () const;
void reset () const;
void clear (CallbackType cbType);
void addCallback (Callback *c, CallbackType t);
void handleExplosion(const btVector3& pos, const MovingPhysics* mo) const;
}
; // CallbackManager
extern CallbackManager *callback_manager;
#endif
/* EOF */

4
src/graphics/moving_texture.hpp
View File

@ -24,11 +24,9 @@
#include "irrlicht.h"
using namespace irr;
#include "callback.hpp"
class XMLNode;
class MovingTexture : public Callback
class MovingTexture
{
private:
/** Translation increment per second. */

12
src/ide/vc9/supertuxkart.vcproj
View File

@ -193,10 +193,6 @@
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="../../../src\callback_manager.cpp"
>
</File>
<File
RelativePath="../../../src\explosion.cpp"
>
@ -687,14 +683,6 @@
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="../../../src\callback.hpp"
>
</File>
<File
RelativePath="../../../src\callback_manager.hpp"
>
</File>
<File
RelativePath="../../../src\constants.hpp"
>

2
src/input/input_manager.cpp
View File

@ -226,7 +226,7 @@ void InputManager::handleStaticAction(int key, int value)
if (race_manager->getNumPlayers() ==1 )
{
Kart* kart = RaceManager::getWorld()->getLocalPlayerKart(0);
// kart->setPowerup(POWERUP_BUBBLEGUM, 10000);
kart->setPowerup(POWERUP_BOWLING, 10000);
kart->attach(ATTACH_ANVIL, 5);
}
break;

2
src/items/attachment_manager.cpp
View File

@ -19,7 +19,6 @@
#include "items/attachment_manager.hpp"
#include "callback_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "io/file_manager.hpp"
@ -60,7 +59,6 @@ void AttachmentManager::removeTextures()
{
// FIXME: free attachment textures
} // for
callback_manager->clear(CB_ATTACHMENT);
} // removeTextures
//-----------------------------------------------------------------------------

3
src/items/flyable.cpp
View File

@ -21,7 +21,6 @@
#include <math.h>
#include "callback_manager.hpp"
#include "race_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/mesh_tools.hpp"
@ -285,7 +284,7 @@ void Flyable::hit(Kart *kart_hit, MovingPhysics* moving_physics)
}
}
}
callback_manager->handleExplosion(pos_explosion, moving_physics);
RaceManager::getTrack()->handleExplosion(pos_explosion, moving_physics);
} // hit
/* EOF */

2
src/items/item_manager.cpp
View File

@ -21,7 +21,6 @@
#include <string>
#include <sstream>
#include "callback_manager.hpp"
#include "user_config.hpp"
#include "material_manager.hpp"
#include "material.hpp"
@ -106,7 +105,6 @@ void ItemManager::removeTextures()
i->second->drop();
}
m_all_meshes.clear();
callback_manager->clear(CB_ITEM);
} // removeTextures
//-----------------------------------------------------------------------------

3
src/items/powerup_manager.cpp
View File

@ -23,7 +23,6 @@
#include <stdexcept>
#include <sstream>
#include "callback_manager.hpp"
#include "material_manager.hpp"
#include "material.hpp"
#include "graphics/irr_driver.hpp"
@ -74,7 +73,7 @@ void PowerupManager::removeTextures()
if(m_all_models[i]) ssgDeRefDelete(m_all_models[i] );
} // for
#endif
callback_manager->clear(CB_COLLECTABLE);
} // removeTextures
//-----------------------------------------------------------------------------

2
src/items/projectile_manager.cpp
View File

@ -57,7 +57,7 @@ void ProjectileManager::removeTextures()
//ssgDeRefDelete(m_explosion_model);
// Only the explosion is here, all other models are actually managed
// by powerup_manager.
callback_manager->clear(CB_EXPLOSION);
//callback_manager->clear(CB_EXPLOSION);
} // removeTextures
//-----------------------------------------------------------------------------

2
src/karts/kart_properties_manager.cpp
View File

@ -25,7 +25,6 @@
#include "stk_config.hpp"
#include "user_config.hpp"
#include "callback_manager.hpp"
#include "challenges/unlock_manager.hpp"
#include "io/file_manager.hpp"
#include "karts/kart_properties.hpp"
@ -60,7 +59,6 @@ void KartPropertiesManager::removeTextures()
delete *i;
}
m_karts_properties.clear();
callback_manager->clear(CB_KART);
} // removeTextures
//-----------------------------------------------------------------------------

11
src/loader.cpp
View File

@ -43,7 +43,6 @@ Loader* loader = 0;
Loader::Loader()
{
m_current_callback_type = CB_COLLECTABLE;
} // Loader
//-----------------------------------------------------------------------------
@ -82,20 +81,12 @@ void Loader::makeModelPath(char* path, const char* FNAME) const
* \param optimise Default is true. If set to false, the model will not
* be flattened.
*/
ssgEntity *Loader::load(const std::string& filename, CallbackType t,
ssgEntity *Loader::load(const std::string& filename,
bool optimise, bool is_full_path)
{
m_current_callback_type = t;
m_is_full_path = is_full_path;
#ifdef HAVE_IRRLICHT
// FIXME: for now
return NULL;
#else
ssgEntity *obj = optimise ? ssgLoad (filename.c_str(), this)
: ssgLoadAC(filename.c_str(), this);
preProcessObj(obj, false);
return obj;
#endif
} // load
//-----------------------------------------------------------------------------

11
src/loader.hpp
View File

@ -25,7 +25,6 @@
#include <string>
#include <vector>
#include <set>
#include "callback_manager.hpp"
class Loader : public ssgLoaderOptions
{
@ -43,20 +42,12 @@ public:
~Loader();
virtual void makeModelPath (char* path, const char* fname) const;
ssgEntity *load(const std::string& filename, CallbackType t, bool optimise=true,
ssgEntity *load(const std::string& filename, bool optimise=true,
bool is_full_path=false);
void setCallbackType(CallbackType t) {m_current_callback_type=t;}
private:
CallbackType m_current_callback_type;
void makePath (std::string& path, const std::string& dir,
const std::string& fname) const;
#ifndef HAVE_IRRLICHT
ssgBranch *createBranch (char *data) const;
void preProcessObj( ssgEntity *n, bool mirror );
ssgBranch *animInit (char *data) const;
#endif
};
extern Loader* loader;

3
src/main.cpp
View File

@ -50,7 +50,6 @@
#include "main_loop.hpp"
#include "material_manager.hpp"
#include "input/input_manager.hpp"
#include "callback_manager.hpp"
#include "history.hpp"
#include "stk_config.hpp"
#include "highscore_manager.hpp"
@ -449,7 +448,6 @@ void InitTuxkart()
kart_properties_manager = new KartPropertiesManager();
projectile_manager = new ProjectileManager ();
powerup_manager = new PowerupManager ();
callback_manager = new CallbackManager ();
item_manager = new ItemManager ();
attachment_manager = new AttachmentManager ();
highscore_manager = new HighscoreManager ();
@ -489,7 +487,6 @@ void CleanTuxKart()
if(highscore_manager) delete highscore_manager;
if(attachment_manager) delete attachment_manager;
if(item_manager) delete item_manager;
if(callback_manager) delete callback_manager;
if(powerup_manager) delete powerup_manager;
if(projectile_manager) delete projectile_manager;
if(kart_properties_manager) delete kart_properties_manager;

10
src/modes/world.cpp
View File

@ -25,7 +25,6 @@
#include "race_manager.hpp"
#include "user_config.hpp"
#include "callback_manager.hpp"
#include "history.hpp"
#include "highscore_manager.hpp"
#include "audio/sound_manager.hpp"
@ -157,7 +156,6 @@ void World::init()
//ssgSetBackFaceCollisions ( !not defined! race_manager->mirror ) ;
#endif
callback_manager->initAll();
// TODO - race GUI
//menu_manager->switchToRace();
@ -175,8 +173,6 @@ World::~World()
// In case that a race is aborted (e.g. track not found) m_track is 0.
if(m_track)
m_track->cleanup();
// Clear all callbacks
callback_manager->clear(CB_TRACK);
for ( unsigned int i = 0 ; i < m_kart.size() ; i++ )
delete m_kart[i];
@ -293,9 +289,8 @@ void World::update(float dt)
projectile_manager->update(dt);
item_manager->update(dt);
/* Routine stuff we do even when paused */
callback_manager->update(dt);
}
} // update
// ----------------------------------------------------------------------------
HighscoreEntry* World::getHighscores() const
@ -513,7 +508,6 @@ void World::restartRace()
item_manager->reset();
projectile_manager->cleanup();
race_manager->reset();
callback_manager->reset();
// Resets the cameras in case that they are pointing too steep up or down
stk_scene->reset();

3
src/physics/moving_physics.hpp
View File

@ -24,14 +24,13 @@
using namespace irr;
#include "btBulletDynamicsCommon.h"
#include "callback.hpp"
#include "user_pointer.hpp"
class Vec3;
class scene::IAnimatedMesh;
class XMLNode;
class MovingPhysics : public Callback
class MovingPhysics
{
public:
enum bodyTypes {MP_NONE, MP_CONE, MP_BOX, MP_SPHERE};

32
src/tracks/track.cpp
View File

@ -28,7 +28,6 @@
#include "stk_config.hpp"
#include "material_manager.hpp"
#include "callback_manager.hpp"
#include "isect.hpp"
#include "user_config.hpp"
#include "audio/sound_manager.hpp"
@ -1283,7 +1282,28 @@ void Track::update(float dt)
{
m_animated_textures[i]->update(dt);
}
for(unsigned int i=0; i<m_physical_objects.size(); i++)
{
m_physical_objects[i]->update(dt);
}
} // update
// ----------------------------------------------------------------------------
/** Handles an explosion, i.e. it makes sure that all physical objects are
* affected accordingly.
* \param pos Position of the explosion.
* \param mp If the hit was a physical object, this object will be affected
* more. Otherwise this is NULL.
*/
void Track::handleExplosion(const Vec3 &pos, const MovingPhysics *mp) const
{
for(std::vector<MovingPhysics*>::const_iterator i=m_physical_objects.begin();
i!=m_physical_objects.end(); i++)
{
(*i)->handleExplosion(pos, mp==(*i));
}
} // handleExplosion
// ----------------------------------------------------------------------------
/** Creates a water node.
* \param node The XML node containing the specifications for the water node.
@ -1376,8 +1396,7 @@ void Track::loadTrackModel()
if(name=="track") continue;
if(name=="object")
{
MovingPhysics *mp = new MovingPhysics(node);
callback_manager->addCallback(mp, CB_TRACK);
m_physical_objects.push_back(new MovingPhysics(node));
}
else if(name=="water")
{
@ -1429,6 +1448,13 @@ void Track::loadTrackModel()
}
// Init all physical objects
for(std::vector<MovingPhysics*>::const_iterator i=m_physical_objects.begin();
i!=m_physical_objects.end(); i++)
{
(*i)->init();
}
#else
std::string path = file_manager->getTrackFile(getIdent()+".loc");

5
src/tracks/track.hpp
View File

@ -77,6 +77,10 @@ private:
/** The list of all animated textures. */
std::vector<MovingTexture*> m_animated_textures;
/** List of all physical objects. */
std::vector<MovingPhysics*> m_physical_objects;
/** If a sky dome is used, the number of horizontal segments
* the sphere should be divided in. */
int m_sky_hori_segments;
@ -217,6 +221,7 @@ public:
float getTerrainHeight(const Vec3 &pos) const;
void createPhysicsModel();
void update(float dt);
void handleExplosion(const Vec3 &pos, const MovingPhysics *mp) const;
void glVtx (sgVec2 v, float x_offset, float y_offset) const
{
glVertex2f(