glvertex_object.h

Go to the documentation of this file.

// (c) by Stefan Roettger, licensed under MIT license
 
#ifndef GLVERTEX_OBJECT_H
#define GLVERTEX_OBJECT_H
 
#include "glvertex.h"
#include "glvertex_nodes.h"
 
#include <list>
 
class lgl_Object
{
public:
 
   lgl_Object()
      : color_(1,1,1),
        transparency_(false),
        partial_trnsp_(false),
        transformation_(1),
        position_(0,0,0),
        scale_(1),
        hidden_(false),
        init_(true)
   {}
 
   virtual ~lgl_Object()
   {}
 
   virtual void initObject() {} // reimplement to initialize object state
   virtual void renderObject() = 0; // reimplement to render a specific object
   virtual void preupdateObject(double dt) {} // reimplement to pre-update the object
   virtual void updateObject(double dt) {} // reimplement to update and change the object
 
   vec4 getColor()
   {
      return(color_);
   }
 
   void setColor(const vec4 &c)
   {
      color_ = c;
      transparency_ = color_.a < 1;
   }
 
   bool hasTransparency()
   {
      return(transparency_);
   }
 
   void hasTransparency(bool flag)
   {
      transparency_ = flag;
   }
 
   bool hasPartialTransparency()
   {
      return(partial_trnsp_);
   }
 
   void hasPartialTransparency(bool flag)
   {
      partial_trnsp_ = flag;
   }
 
   mat4 getTransformation()
   {
      return(transformation_);
   }
 
   void setTransformation(const mat4 &m)
   {
      transformation_ = m;
      position_ = m.getTranslation();
   }
 
   vec3 getPosition()
   {
      return(position_);
   }
 
   mat3 getRotation()
   {
      return(transformation_.getRotation());
   }
 
   vec3 getScale()
   {
      return(scale_);
   }
 
   double getMaxScale()
   {
      double s = scale_.x;
      if (scale_.y > s) s = scale_.y;
      if (scale_.z > s) s = scale_.z;
      return(s);
   }
 
   bool hasUniformScale()
   {
      return(scale_.x==scale_.y && scale_.y==scale_.z);
   }
 
   virtual vec3 getCenter()
   {
      return(vec3(0,0,0));
   }
 
   virtual vec3 getExtent()
   {
      return(vec3(0,0,0));
   }
 
   virtual double getRadius()
   {
      return(0);
   }
 
   virtual double getNorm()
   {
      return(0);
   }
 
   void move(const vec3 &delta)
   {
      transformation_ <<= mat4::translate(delta);
      position_ = transformation_.getTranslation();
   }
 
   void rotate(const quat &q)
   {
      transformation_ *= mat3(q);
   }
 
   void scale(double factor)
   {
      scale_ *= factor;
   }
 
   void scale(const vec3 &factor)
   {
      scale_ *= factor;
   }
 
   bool hidden()
   {
      return(hidden_);
   }
 
   bool shown()
   {
      return(!hidden_);
   }
 
   void hide(bool yes = true)
   {
      hidden_ = yes;
   }
 
   void show(bool yes = true)
   {
      hidden_ = !yes;
   }
 
   void renderTransformedObject()
   {
      if (!hidden_)
      {
         lglPushMatrix();
         lglMultMatrix(transformation_);
         if (scale_ != vec3(1)) lglScale(scale_);
         lglColor(color_);
         renderObject();
         lglPopMatrix();
      }
   }
 
   virtual double getDistanceToObject(const vec3 &v)
   {
      return(getDistanceToSphere(getPosition(), v, getRadius()));
   }
 
protected:
 
   vec4 color_;
   bool transparency_;
   bool partial_trnsp_;
   mat4 transformation_;
   vec3 position_;
   vec3 scale_;
   bool hidden_;
   bool init_;
 
   bool init()
   {
      if (init_)
      {
         init_ = false;
         return(true);
      }
 
      return(false);
   }
 
   static double getDistanceToSphere(const vec3 &p, const vec3 &v, double radius)
   {
      vec3 d = p-v;
      double l = d.length()-radius;
      return(l);
   }
 
   static double getDistanceToBox(const vec3 &p, const vec3 &v, const vec3 &ext)
   {
      vec3 d = p-v;
      if (d.x < 0) d.x = -d.x;
      if (d.y < 0) d.y = -d.y;
      if (d.z < 0) d.z = -d.z;
      d -= ext/2;
      if (d.x<0 && d.y<0 && d.z<0)
      {
         double l = d.x;
         if (d.y > l) l = d.y;
         if (d.z > l) l = d.z;
         return(l);
      }
      else
      {
         if (d.x < 0) d.x = 0;
         if (d.y < 0) d.y = 0;
         if (d.z < 0) d.z = 0;
         return(d.length());
      }
   }
 
   static double getDistanceToBox(const vec3 &p, const mat3 &rotation, const vec3 &v, const vec3 &ext)
   {
      return(getDistanceToBox(p, rotation.invert()*(v-p)+p, ext));
   }
 
   static double getDistanceToBox(const vec3 &p, const mat3 &rotation, const vec3 &offset, const vec3 &v, const vec3 &ext)
   {
      return(getDistanceToBox(p+offset, rotation.invert()*(v-p)+p, ext));
   }
 
   friend class lgl_Objects;
   friend class lgl_DepthSortedObjects;
};
 
class lgl_GeometryObject: public lgl_Object
{
public:
 
   lgl_GeometryObject(lglVBO *vbo = NULL)
      : lgl_Object(),
        vbo_(vbo)
   {}
 
   virtual ~lgl_GeometryObject()
   {}
 
   lglVBO *getVBO()
   {
      return(vbo_);
   }
 
   void setVBO(lglVBO *vbo)
   {
      vbo_ = vbo;
   }
 
   virtual vec3 getCenter()
   {
      if (vbo_)
         return(vbo_->lglGetCenter()*getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual vec3 getExtent()
   {
      if (vbo_)
         return(vbo_->lglGetExtent()*getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual double getRadius()
   {
      if (vbo_)
         return(vbo_->lglGetRadius()*getMaxScale());
 
      return(0);
   }
 
   virtual double getNorm()
   {
      if (vbo_)
      {
         double s = getMaxScale();
         return(vbo_->lglGetNorm()*s*s);
      }
 
      return(0);
   }
 
   virtual void renderObject()
   {
      if (vbo_)
         vbo_->lglRender();
   }
 
   virtual double getDistanceToObject(const vec3 &v)
   {
      return(getDistanceToBox(getPosition(), getRotation(), v, getExtent()));
   }
 
protected:
 
   lglVBO *vbo_;
};
 
class lgl_SceneGraphObject: public lgl_Object
{
public:
 
   lgl_SceneGraphObject(lgl_Node *root = NULL)
      : lgl_Object(),
        root_(NULL)
   {
      setSceneGraph(root);
   }
 
   virtual ~lgl_SceneGraphObject()
   {
      if (root_)
         delete root_;
   }
 
   lgl_Node *getSceneGraph()
   {
      return(root_);
   }
 
   void setSceneGraph(lgl_Node *root)
   {
      if (root_)
         delete root_;
 
      root_ = root;
 
      if (root_->hasTransparency())
      {
         hasTransparency(true);
         hasPartialTransparency(true);
      }
   }
 
   virtual vec3 getCenter()
   {
      if (root_)
         return(root_->getCenter()*getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual vec3 getExtent()
   {
      if (root_)
         return(root_->getExtent()*getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual double getRadius()
   {
      if (root_)
         return(root_->getRadius()*getMaxScale());
 
      return(0);
   }
 
   virtual double getNorm()
   {
      if (root_)
      {
         double s = getMaxScale();
         return(root_->getNorm()*s*s);
      }
 
      return(0);
   }
 
   virtual void renderObject()
   {
      if (root_)
         root_->drawSceneGraph();
   }
 
   virtual void preupdateObject(double dt)
   {
      if (root_)
         root_->preupdateSceneGraph(dt);
   }
 
   virtual void updateObject(double dt)
   {
      if (root_)
         root_->updateSceneGraph(dt);
   }
 
   virtual double getDistanceToObject(const vec3 &v)
   {
      return(getDistanceToBox(getPosition(), getRotation(), getCenter(), v, getExtent()));
   }
 
protected:
 
   lgl_Node *root_;
};
 
class lgl_CubeObject: public lgl_GeometryObject
{
public:
 
   lgl_CubeObject()
      : lgl_GeometryObject()
   {
      static lglCube cube;
      setVBO(&cube);
   }
 
};
 
class lgl_SphereObject: public lgl_GeometryObject
{
public:
 
   lgl_SphereObject()
      : lgl_GeometryObject()
   {
      static lglSphere sphere;
      setVBO(&sphere);
   }
 
   virtual double getDistanceToObject(const vec3 &v)
   {
      return(getDistanceToSphere(getPosition(), v, getRadius()));
   }
 
protected:
 
   virtual double getRadius()
   {
      return(0.5*getMaxScale());
   }
 
   virtual double getNorm()
   {
      double s = getMaxScale();
      return(0.25*s*s);
   }
 
};
 
// helper class that provides the 'less' compare operator for depth sorting
class lgl_DepthSortCompare
{
public:
 
   lgl_DepthSortCompare(vec3 eye)
      : eye_(eye)
   {}
 
   bool operator() (lgl_Object *a, lgl_Object *b) const
   {
      return((a->getPosition()-eye_).norm() >
             (b->getPosition()-eye_).norm());
   }
 
protected:
 
   vec3 eye_;
};
 
class lgl_DepthSortedObjects: public std::vector<lgl_Object*>
{
public:
 
   typedef std::vector<lgl_Object*>::iterator iterator;
 
   lgl_DepthSortedObjects()
      : std::vector<lgl_Object*>()
   {}
 
   virtual ~lgl_DepthSortedObjects()
   {}
 
   virtual void drawObjects(vec3 eye)
   {
      depthSort(eye);
 
      for (iterator it=begin(); it!=end(); it++)
      {
         if ((*it)->init())
            (*it)->initObject();
 
         (*it)->renderTransformedObject();
      }
   }
 
protected:
 
   void depthSort(vec3 eye)
   {
      lgl_DepthSortCompare customLess(eye);
      std::sort(begin(), end(), customLess);
   }
 
};
 
class lgl_Objects: protected std::list<lgl_Object*>
{
public:
 
   typedef std::list<lgl_Object*>::iterator iterator;
 
   lgl_Objects()
      : std::list<lgl_Object*>(),
        selected_(end())
   {}
 
   virtual ~lgl_Objects()
   {
      for (iterator it=begin(); it!=end(); it++)
         delete *it;
   }
 
   virtual iterator addObject(lgl_Object *obj)
   {
      push_back(obj);
      return(--end());
   }
 
   iterator findObject(lgl_Object *obj)
   {
      for (iterator it=begin(); it!=end(); it++)
         if (*it == obj)
            return(it);
 
      return(end());
   }
 
   iterator findObject(vec3 center, double radius)
   {
      iterator result = end();
      double distance = radius;
 
      for (iterator it=begin(); it!=end(); it++)
      {
         double d = (*it)->getDistanceToObject(center);
 
         if (d <= radius)
            if (d <= distance)
            {
               result = it;
               distance = d;
            }
      }
 
      return(result);
   }
 
   void selectObject(iterator it)
   {
      selected_ = it;
   }
 
   iterator getSelectedObject()
   {
      return(selected_);
   }
 
   virtual void removeObject(iterator it)
   {
      if (it == selected_)
         selected_ = end();
 
      delete *it;
      erase(it);
   }
 
   iterator begin()
   {
      return(std::list<lgl_Object*>::begin());
   }
 
   iterator end()
   {
      return(std::list<lgl_Object*>::end());
   }
 
   void renderObjects(double dt = 0)
   {
      preupdateObjects(dt);
      drawObjects();
      updateObjects(dt);
   }
 
   void renderObjects(vec3 eye, double dt = 0)
   {
      preupdateObjects(dt);
      drawObjects(eye);
      updateObjects(dt);
   }
 
   virtual void drawObjects()
   {
      for (iterator it=begin(); it!=end(); it++)
      {
         if ((*it)->init())
            (*it)->initObject();
 
         (*it)->renderTransformedObject();
      }
   }
 
   virtual void drawObjects(vec3 eye)
   {
      lgl_DepthSortedObjects objs;
      lgl_DepthSortedObjects partial_objs;
 
      // opaque bin
      for (iterator it=begin(); it!=end(); it++)
      {
         if ((*it)->init())
            (*it)->initObject();
 
         if (!((*it)->hasTransparency()))
            (*it)->renderTransformedObject();
         else
            if (!((*it)->hasPartialTransparency()))
               objs.push_back(*it);
            else
               partial_objs.push_back(*it);
      }
 
      // transparent bin
      partial_objs.drawObjects(eye);
      bool zwrite = lglGetZWrite();
      lglZWrite(false);
      objs.drawObjects(eye);
      lglZWrite(zwrite);
   }
 
   virtual void preupdateObjects(double dt)
   {
      for (iterator it=begin(); it!=end(); it++)
      {
         if ((*it)->init())
            (*it)->initObject();
 
         (*it)->preupdateObject(dt);
      }
   }
 
   virtual void updateObjects(double dt)
   {
      for (iterator it=begin(); it!=end(); it++)
      {
         if ((*it)->init())
            (*it)->initObject();
 
         (*it)->updateObject(dt);
      }
   }
 
protected:
 
   iterator selected_;
};
 
template<typename T>
class lgl_PhysicalObject: public lgl_Object
{
public:
 
   lgl_PhysicalObject()
      : lgl_Object(),
        mass_(0), restitution_(1),
        velocity_(0,0,0),
        data_(NULL)
   {}
 
   virtual ~lgl_PhysicalObject()
   {
      if (data_)
         delete data_;
   }
 
   T *getPhysicalData()
   {
      return(data_);
   }
 
   void setPhysicalData(T *data)
   {
      if (data_)
         delete data_;
 
      data_ = data;
   }
 
   virtual T *createPhysicalData()
   {
      return(NULL);
   }
 
   double getPhysicalMass()
   {
      return(mass_);
   }
 
   void setPhysicalMass(double mass)
   {
      mass_ = mass;
   }
 
   double getPhysicalRestitution()
   {
      return(restitution_);
   }
 
   void setPhysicalRestitution(double restitution)
   {
      restitution_ = restitution;
   }
 
   void setTransformation(const mat4 &m)
   {
      lgl_Object::setTransformation(m);
 
      if (getPhysicalData())
         transformationChanged(transformation_);
   }
 
   virtual mat4 getPhysicalTransformation() = 0; // to be implemented by physics engine
 
   void setPhysicalTransformation(const mat4 &m)
   {
      lgl_Object::setTransformation(m);
   }
 
   void move(const vec3 &delta)
   {
      lgl_Object::move(delta);
 
      if (getPhysicalData())
         transformationChanged(transformation_);
   }
 
   void rotate(const quat &q)
   {
      lgl_Object::rotate(q);
 
      if (getPhysicalData())
         transformationChanged(transformation_);
   }
 
   void scale(double factor)
   {
      if (!getPhysicalData())
         lgl_Object::scale(factor);
   }
 
   void scale(vec3 factor)
   {
      if (!getPhysicalData())
         lgl_Object::scale(factor);
   }
 
   void setVelocity(vec3 velocity)
   {
      velocity_ = velocity;
 
      if (getPhysicalData())
         velocityChanged(velocity_);
   }
 
   vec3 getVelocity()
   {
      return(velocity_);
   }
 
   virtual vec3 getPhysicalVelocity() = 0; // to be implemented by physics engine
 
   void setPhysicalVelocity(vec3 velocity)
   {
      velocity_ = velocity;
   }
 
   virtual void applyForce(vec3 force, vec3 rel_pos = vec3(0,0,0)) = 0; // to be implemented by physics engine
 
   virtual void applyImpulse(vec3 impulse) = 0; // to be implemented by physics engine
 
   virtual void applyTorque(vec3 torque) = 0; // to be implemented by physics engine
 
protected:
 
   double mass_;
   double restitution_;
   vec3 velocity_;
 
   T *data_;
 
   virtual void transformationChanged(const mat4 &m) = 0; // to be implemented by physics engine
   virtual void velocityChanged(const vec3 &v) = 0; // to be implemented by physics engine
};
 
template<typename T>
class lgl_PhysicalGeometryObject: public lgl_PhysicalObject<T>
{
public:
 
   lgl_PhysicalGeometryObject(lglVBO *vbo = NULL)
      : lgl_PhysicalObject<T>(),
        vbo_(vbo)
   {}
 
   virtual ~lgl_PhysicalGeometryObject()
   {}
 
   lglVBO *getVBO()
   {
      return(vbo_);
   }
 
   void setVBO(lglVBO *vbo)
   {
      vbo_ = vbo;
   }
 
   virtual vec3 getCenter()
   {
      if (vbo_)
         return(vbo_->lglGetCenter()*lgl_PhysicalObject<T>::getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual vec3 getExtent()
   {
      if (vbo_)
         return(vbo_->lglGetExtent()*lgl_PhysicalObject<T>::getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual double getRadius()
   {
      if (vbo_)
         return(vbo_->lglGetRadius()*lgl_PhysicalObject<T>::getMaxScale());
 
      return(0);
   }
 
   virtual double getNorm()
   {
      if (vbo_)
      {
         double s = lgl_PhysicalObject<T>::getMaxScale();
         return(vbo_->lglGetNorm()*s*s);
      }
 
      return(0);
   }
 
   virtual void renderObject()
   {
      if (vbo_)
         vbo_->lglRender();
   }
 
protected:
 
   lglVBO *vbo_;
};
 
class lgl_NoPhysicalGeometryObject: public lgl_PhysicalGeometryObject<void*>
{
public:
 
   virtual mat4 getPhysicalTransformation()
   {
      return(getTransformation());
   }
 
   virtual vec3 getPhysicalVelocity()
   {
      return(getVelocity());
   }
 
   virtual void applyForce(vec3 force, vec3 rel_pos = vec3(0,0,0)) {}
   virtual void applyImpulse(vec3 impulse) {}
   virtual void applyTorque(vec3 torque) {}
 
protected:
 
   virtual void transformationChanged(const mat4 &m) {}
   virtual void velocityChanged(const vec3 &v) {}
};
 
template<typename T>
class lgl_PhysicalSceneGraphObject: public lgl_PhysicalObject<T>
{
public:
 
   lgl_PhysicalSceneGraphObject(lgl_Node *root = NULL)
      : lgl_PhysicalObject<T>(),
        root_(NULL)
   {
      setSceneGraph(root);
   }
 
   virtual ~lgl_PhysicalSceneGraphObject()
   {
      if (root_)
         delete root_;
   }
 
   lgl_Node *getSceneGraph()
   {
      return(root_);
   }
 
   void setSceneGraph(lgl_Node *root)
   {
      if (root_)
         delete root_;
 
      root_ = root;
 
      if (root_->hasTransparency())
      {
         lgl_PhysicalObject<T>::hasTransparency(true);
         lgl_PhysicalObject<T>::hasPartialTransparency(true);
      }
   }
 
   virtual vec3 getCenter()
   {
      if (root_)
         return(root_->getCenter()*lgl_PhysicalObject<T>::getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual vec3 getExtent()
   {
      if (root_)
         return(root_->getExtent()*lgl_PhysicalObject<T>::getScale());
 
      return(vec3(0,0,0));
   }
 
   virtual double getRadius()
   {
      if (root_)
         return(root_->getRadius()*lgl_PhysicalObject<T>::getMaxScale());
 
      return(0);
   }
 
   virtual double getNorm()
   {
      if (root_)
      {
         double s = lgl_PhysicalObject<T>::getMaxScale();
         return(root_->getNorm()*s*s);
      }
 
      return(0);
   }
 
   virtual void renderObject()
   {
      if (root_)
         root_->drawSceneGraph();
   }
 
   virtual void preupdateObject(double dt)
   {
      if (root_)
         root_->preupdateSceneGraph(dt);
   }
 
   virtual void updateObject(double dt)
   {
      if (root_)
         root_->updateSceneGraph(dt);
   }
 
protected:
 
   lgl_Node *root_;
};
 
class lgl_NoPhysicalSceneGraphObject: public lgl_PhysicalSceneGraphObject<void*>
{
public:
 
   virtual mat4 getPhysicalTransformation()
   {
      return(getTransformation());
   }
 
   virtual vec3 getPhysicalVelocity()
   {
      return(getVelocity());
   }
 
   virtual void applyForce(vec3 force, vec3 rel_pos = vec3(0,0,0)) {}
   virtual void applyImpulse(vec3 impulse) {}
   virtual void applyTorque(vec3 torque) {}
 
protected:
 
   virtual void transformationChanged(const mat4 &m) {}
   virtual void velocityChanged(const vec3 &v) {}
};
 
template<typename T>
class lgl_PhysicalCubeObject: public lgl_PhysicalGeometryObject<T>
{
public:
 
   lgl_PhysicalCubeObject()
      : lgl_PhysicalGeometryObject<T>()
   {
      static lglCube cube;
      lgl_PhysicalGeometryObject<T>::setVBO(&cube);
   }
 
};
 
class lgl_NoPhysicalCubeObject: public lgl_PhysicalCubeObject<void*>
{
public:
 
   virtual mat4 getPhysicalTransformation()
   {
      return(getTransformation());
   }
 
   virtual vec3 getPhysicalVelocity()
   {
      return(getVelocity());
   }
 
   virtual void applyForce(vec3 force, vec3 rel_pos = vec3(0,0,0)) {}
   virtual void applyImpulse(vec3 impulse) {}
   virtual void applyTorque(vec3 torque) {}
 
protected:
 
   virtual void transformationChanged(const mat4 &m) {}
   virtual void velocityChanged(const vec3 &v) {}
};
 
template<typename T>
class lgl_PhysicalSphereObject: public lgl_PhysicalGeometryObject<T>
{
public:
 
   lgl_PhysicalSphereObject()
      : lgl_PhysicalGeometryObject<T>()
   {
      static lglSphere sphere;
      lgl_PhysicalGeometryObject<T>::setVBO(&sphere);
   }
 
protected:
 
   virtual double getRadius()
   {
      return(0.5*lgl_PhysicalGeometryObject<T>::getMaxScale());
   }
 
   virtual double getNorm()
   {
      double s = lgl_PhysicalGeometryObject<T>::getMaxScale();
      return(0.25*s*s);
   }
 
};
 
class lgl_NoPhysicalSphereObject: public lgl_PhysicalSphereObject<void*>
{
public:
 
   virtual mat4 getPhysicalTransformation()
   {
      return(getTransformation());
   }
 
   virtual vec3 getPhysicalVelocity()
   {
      return(getVelocity());
   }
 
   virtual void applyForce(vec3 force, vec3 rel_pos = vec3(0,0,0)) {}
   virtual void applyImpulse(vec3 impulse) {}
   virtual void applyTorque(vec3 torque) {}
 
protected:
 
   virtual void transformationChanged(const mat4 &m) {}
   virtual void velocityChanged(const vec3 &v) {}
};
 
template<typename T>
class lgl_PhysicalObjects: public lgl_Objects
{
public:
 
   typedef lgl_Objects::iterator iterator;
 
   lgl_PhysicalObjects()
      : lgl_Objects(),
        ground_o(0,0,0),
        ground_n(0,1,0),
        ground_g(-9.81),
        ground_r(1.0)
   {}
 
   virtual ~lgl_PhysicalObjects()
   {}
 
   virtual iterator addObject(lgl_Object *obj)
   {
      if (lgl_PhysicalObject<T> *pobj=dynamic_cast<lgl_PhysicalObject<T>*>(obj))
      {
         T *data = pobj->createPhysicalData();
         pobj->setPhysicalData(data);
         objectAdded(pobj);
      }
 
      return(lgl_Objects::addObject(obj));
   }
 
   iterator findNonStaticObject(vec3 center, double radius)
   {
      iterator result = end();
      double distance = radius;
 
      for (iterator it=begin(); it!=end(); it++)
         if (lgl_PhysicalObject<T> *pobj=dynamic_cast<lgl_PhysicalObject<T>*>(*it))
            if (pobj->getPhysicalMass() > 0)
            {
               double d = pobj->getDistanceToObject(center);
 
               if (d <= radius)
                  if (d <= distance)
                  {
                     result = it;
                     distance = d;
                  }
            }
 
      return(result);
   }
 
   virtual void removeObject(iterator it)
   {
      if (lgl_PhysicalObject<T> *pobj=dynamic_cast<lgl_PhysicalObject<T>*>(*it))
         objectRemoved(pobj);
 
      lgl_Objects::removeObject(it);
   }
 
   virtual void deactivateObject(iterator it, bool yes = true)
   {
      if (lgl_PhysicalObject<T> *pobj=dynamic_cast<lgl_PhysicalObject<T>*>(*it))
         objectDeactivated(pobj, yes);
   }
 
   iterator begin()
   {
      return(lgl_Objects::begin());
   }
 
   iterator end()
   {
      return(lgl_Objects::end());
   }
 
   void setGroundPlane(vec3 o, vec3 n, double r = 1.0)
   {
      ground_o = o;
      ground_n = n;
      ground_r = r;
   }
 
   void setGravity(double g)
   {
      ground_g = g;
   }
 
protected:
 
   vec3 ground_o;
   vec3 ground_n;
 
   double ground_g;
   double ground_r;
 
   virtual void updateObjects(double dt)
   {
      updatePhysicalObjects(dt);
 
      for (iterator it=begin(); it!=end(); it++)
      {
         if (lgl_PhysicalObject<T> *pobj=dynamic_cast<lgl_PhysicalObject<T>*>(*it))
         {
            mat4 m = pobj->getPhysicalTransformation();
            pobj->setPhysicalTransformation(m);
 
            vec3 v = pobj->getPhysicalVelocity();
            pobj->setPhysicalVelocity(v);
         }
      }
 
      lgl_Objects::updateObjects(dt);
   }
 
   virtual void objectAdded(lgl_PhysicalObject<T> *pobj) = 0; // to be implemented by physics engine
   virtual void objectRemoved(lgl_PhysicalObject<T> *pobj) = 0; // to be implemented by physics engine
   virtual void objectDeactivated(lgl_PhysicalObject<T> *pobj, bool yes) = 0; // to be implemented by physics engine
   virtual void updatePhysicalObjects(double dt) = 0; // to be implemented by physics engine
};
 
class lgl_NoPhysicalObjects: public lgl_PhysicalObjects<void*>
{
protected:
 
   virtual void objectAdded(lgl_PhysicalObject<void*> *pobj) {}
   virtual void objectRemoved(lgl_PhysicalObject<void*> *pobj) {}
   virtual void objectDeactivated(lgl_PhysicalObject<void*> *pobj, bool yes) {}
   virtual void updatePhysicalObjects(double dt) {}
};
 
#endif