Changeset 544 for branches/netent_demo/netent.h

Timestamp:

03/08/10 22:52:07 (6 months ago)

Author:

gaul@…

Message:

more simplification tests

Files:

• branches/netent_demo/netent.h (modified) (3 diffs)

branches/netent_demo/netent.h

@@ -1 +1 @@
 #include <string>
+#include <iostream>
+#include <ode/ode.h>
+
+using namespace std;
+
+
+//see below for example
+#define ENTLEAF(CLASS, CLASSID, CLASSNAME) \
+                virtual uint16_t get_classid() { return Ent::CLASSID; };\
+                virtual const std::string get_classname() { return CLASSNAME; }; \
+                static Ent* create(Game *game, uint16_t entid) { return new CLASS(game, entid); }; 
+
+//always declare constructor as protected!
+#define ENTLEAFCON(CLASS, PARENT) \
+                CLASS(Game *game, uint16_t entid) : PARENT(game, entid) {};
+
+class Game;
 
 class Ent {
         protected: //do not instantiate directly
-                Ent(uint16_t _entid) {
+                Ent(Game *_game, uint16_t _entid) {
+                        game = _game;
                         entid = _entid;
                 };
         private:
+                Game *game;
                 uint16_t entid;
         public:
@@ -15 +34 @@
                         PlayerBall
                 } Class;
-                typedef Ent* (*createfct)(uint16_t);
+                typedef Ent* (*createfct)(Game *, uint16_t);
                 uint16_t get_entid() { return entid; };
                 virtual uint16_t get_classid() = 0;
@@ -21 +40 @@
 };
 
-class Obj : public Ent {
-        protected: 
-                Obj(uint16_t entid) : Ent(entid) {};
+
+class Game {
+        private:
+                map<uint16_t, Ent::createfct> id2ent;
+                map<uint16_t, Ent*> ents;
+                uint16_t entcnt;
+        public:
+                Game();
+                virtual Ent *entcreate(uint16_t classid) {
+                        Ent::createfct createfct=id2ent[classid];
+                        if (!createfct) {
+                                cout << classid << "No createfct! earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                        Ent *ent = createfct(this, entcnt);
+                        if (!ent) {
+                                cout << entcnt << "No ent! earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                        ents[entcnt++]=ent;
+                        return ent;
+                };
+
+                virtual void entdelete(uint16_t entid) {
+                        Ent *ent=ents[entid];
+                        if (!ent) {
+                                cout << entcnt << "No ent! earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                        ents.erase(entid);
+                        delete ent;
+                };
+
+                template <class CLASS> CLASS * entcreate(uint16_t classid) {
+                        CLASS *ent=dynamic_cast<CLASS *>(entcreate(classid));
+                        if (!ent) {
+                                cout << classid << "No createfct! earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                        return ent;
+                };
+
+                virtual ~Game() {}; //needed in order to do dynamic_cast<ODEGame *>(Game *)
 };
 
-class Box : public Obj {
-        protected:
-                Box(uint16_t entid) : Obj(entid) {};
+class ODEGame : public Game {
         public:
-                virtual uint16_t get_classid() { return Ent::Box; };
-                virtual const std::string get_classname() { return "Box"; };
-                static Ent* create(uint16_t entid) { return new Box(entid); }; //Ent* seems to be needed
+                dWorld world;
+                dSimpleSpace space;
+                ODEGame() {} ;
 };
 
-class Pad : public Box {
+//non-leaf Ent
+class ODEEnt : public Ent {
+        private:
+                ODEGame *odegame;
         protected:
-                Pad(uint16_t entid) : Box(entid) {};
-        public:
-                virtual uint16_t get_classid() { return Ent::Pad; };
-                virtual const std::string get_classname() { return "Pad"; };
-                static Ent* create(uint16_t entid) { return new Pad(entid); };
+                ODEEnt(Game *game, uint16_t entid) : Ent(game, entid) {
+                        odegame = dynamic_cast<ODEGame*>(game);
+                        if (!odegame) {
+                                //throw earth-shaking exception (since we've been cheated!!!)
+                                cout << "earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                };
+                ODEGame *getodegame() { return odegame; };
 };
 
-#define ENTLEAF(CLASS, CLASSID, CLASSNAME) \
-                virtual uint16_t get_classid() { return Ent::CLASSID; };\
-                virtual const std::string get_classname() { return CLASSNAME; }; \
-                static Ent* create(uint16_t entid) { return new CLASS(entid); }; 
-
-//now this is shorter (!):
-class Sphere : public Ent {
+//example of non-leaf Ent (note the dGeom* parameter for constructor)
+class ODEBody : public ODEEnt {
+        private:
+                dBody body;
+                dGeom *geom;
         protected:
-                Sphere(uint16_t entid) : Ent(entid) {};
-        public:
-                ENTLEAF(Sphere, Sphere, "Sphere");
+                ODEBody(Game *game, uint16_t entid, dGeom *_geom) : ODEEnt(game, entid) {
+                        body.create(getodegame()->world);
+                        body.setData(this);
+                        geom = _geom;
+                        if (!geom) { //we only allow Bodys with a geometry
+                                //throw earth-shaking exception (since we've been cheated!!!)
+                                cout << entid << "earth-shaking exception would be thrown in production code!" << endl;
+                        }
+                        getodegame()->space.add(*geom);
+                };
+                template <class GEOM> GEOM *getgeom() {
+                        return static_cast<GEOM *>(geom); //no way to check since dGeom isnt polymorphic
+                }
+                //TODO:
+                void setposition(dReal x) {};
 };
 
-class PBall : public Sphere {
+class ODEBox : public ODEBody {
         protected:
-                PBall(uint16_t entid) : Sphere(entid) {};
+                ODEBox(Game *game, uint16_t entid) : ODEBody(game, entid, new dBox(1.0,1.0,1.0)) {};
         public:
-                ENTLEAF(PBall, PlayerBall, "PlayerBall");
+                ENTLEAF(ODEBox, Box, "Box");
+                //TODO: setbox()
 };
+
+class ODEPad : public ODEBox {
+        protected:
+                ENTLEAFCON(ODEPad, ODEBox);
+        public:
+                ENTLEAF(ODEPad, Pad, "Pad");
+};
+
+class ODESphere : public ODEBody {
+        protected:
+                ODESphere(Game *game, uint16_t entid) : ODEBody(game, entid, new dSphere(1.0)) {};
+        public:
+                ENTLEAF(ODESphere, Sphere, "Sphere");
+                void setradius(dReal r) { getgeom<dSphere>()->setRadius(r); };
+                dReal getradius() { return getgeom<dSphere>()->getRadius(); };
+};
+
+class ODEPBall : public ODESphere {
+        protected:
+                ENTLEAFCON(ODEPBall, ODESphere);
+        public:
+                ENTLEAF(ODEPBall, PlayerBall, "PlayerBall");
+};