gobjbase.h

Go to the documentation of this file.

#ifndef GOBJBASE_H
#define GOBJBASE_H

#include <cassert>
#include <deque>
#include <vector>
#include <iostream>
using namespace std;

#include <GL/glut.h>
#include <GL/gl.h>

#include <fnobjTfn.h>
#include <point.h>
#include <print.h>
#include <typedefs.h>

#define gobjpush(x) assert(gobjContainer::global != 0); gobj::global->push(x)
#define DOUBLECOLOR(uR,uG,uB) 1.0*uR/256.0, 1.0*uG/256.0, 1.0*uB/256.0 

#include <gobjdebug.h>



class gobjContainer;

/*
\brief Scene base class.

It is assumed that the scene is a vector of gobj pointers. 
 ie a stack.  See gobjContainer.  I believe a stack is more 
 general and powerful than a scene graph which is assumed 
 to be a tree.  A vector contains trees as a subset. 

An important application is that vectors can be easily 
 indexed with integers. Contrast this with a scene graph 
 which is often implemented with pointers.

All graphics objects can draw (unless they exist in a gobj 
 stack for other purposes).

All graphics sees the universal graphics stream 
 gobj::global. (This is currently a single threaded design, 
 but this may be changed).
*/
class gobj
{
public:

  static gobjContainer * global;

  static void globaldisplaylist(uintc id);

  virtual void draw() = 0;

  virtual ~gobj();

};

class gobjGlobal
{
  gobjContainer * const globalnew;
  gobjGlobal() : globalnew(0) {}
public:

  gobjGlobal(gobjContainer * const globalnew_);
  // TODO
  //gobjGlobal(gobjContainer& globalnew_);

  ~gobjGlobal();
};


template< typename T >
class gobjglCallList : public gobj
{
public:

  T listid;

  gobjglCallList(T listid_)
    : listid(listid_) {}

  void draw()
    { GOBJDEBUGCODE glCallList(listid); }

};


template< class T >
class gobjcallback : public gobj
{
  fnobj0Tfn<T,void> fobj;
public:

  typedef void (T::*Fptr)();

  gobjcallback( T & data_, Fptr fn_)
    : fobj(data_,fn_) {}

  void draw()
    { GOBJDEBUGCODE fobj(); }

};

template< class T >
gobjcallback<T>* gobjcallbackcreatenew(T & data_, void (T::*fn_)() )
  { return new gobjcallback<T>(data_,fn_); }


class gobjContainer : public gobj
{
public:

  void set() 
    { gobj::global = this; }

  static vector< gobjContainer * > globalvec;

  void globalpush() 
    { globalvec.push_back( gobj::global); set(); }

  static void globalpop();

  vector<gobj*> vg;

  bool cleanup;

  gobjContainer();
  gobjContainer(boolc cleanup_);
  ~gobjContainer();

  void nuke();

  boolc kill(uintc k);
  boolc kill(gobj* const targ);

  void draw();

  void push(gobj * g)
    { assert(g!=0); vg.push_back(g); }
  template< class T >
  void pushcallback(T & data_, void (T::*fn_)() )
   { push(new gobjcallback<T>(data_,fn_)); }

  gobjglCallList<GLuint> * displaylistcreatenew(uint id);

  void displaylist(uintc id);
};

class gobjContainerdeque : public gobj
{
public:

  void push_front(gobj* g)
    { assert(g!=0); vg.push_front(g); }
  void push_back(gobj* g)
    { assert(g!=0); vg.push_back(g); }

  void draw();

  deque<gobj*> vg;

  bool cleanup;

  gobjContainerdeque()
    : cleanup(true) {};

  gobjContainerdeque(boolc cleanup_)
    : cleanup(cleanup_) {};
  ~gobjContainerdeque();

  void nuke();

};

template< typename BOOL=bool >
class gobjSwitch;

class gobjContainerSwitch : public gobj
{
public:

  gobjContainer gcontainer;
  vector< gobjSwitch<>* > gswitch; 

  gobjContainerSwitch(boolc cleanup_);

  void draw()
    { GOBJDEBUGCODE gcontainer.draw(); }
  
  void nuke();
  ~gobjContainerSwitch();

  gobjSwitch<> * push(gobj* g);
};


class gobjContainerPrePost : public gobjContainer
{
public:

  gobjContainer pre;
  gobjContainer post;

  void draw();

  gobjContainerPrePost(boolc cleanup_=false)
    : gobjContainer(cleanup_), pre(cleanup_), post(cleanup_) {}

};


template< typename BOOL >
class gobjSwitch : public gobj
{ 
public:

  gobj * x;

  BOOL isdrawn;
  bool cleanup;

  gobjSwitch
  (
    gobj * x_,
    BOOL isdrawn_, 
    boolc cleanup_=true
  )
    : x(x_), isdrawn(isdrawn_), cleanup(cleanup_) 
    { }

  ~gobjSwitch()
    { if (cleanup==false) return; delete x; x=0; }

  void draw()
    { GOBJDEBUGCODE assert(x!=0); if (isdrawn) x->draw(); }

  void toggle()
    { assert(x!=0); isdrawn = ! isdrawn; }

};


template< class T >
class gobjcallbackcontainer : public gobj
{
  fnobj1Tfn<T,void,gobjContainer&> fobj;
public:

  typedef void (T::*Fptr)(gobjContainer&);

  gobjcallbackcontainer( T & data_, Fptr fn_)
    : fobj(data_,fn_) {}

  void draw()
  { 
    GOBJDEBUGCODE
    gobjContainer* shp = new gobjContainer(true);
    
    fobj(*shp); 
    gobjpush(shp);
  }

};

template< class T >
gobjcallbackcontainer<T>* gobjcallbackcontainercreatenew
(
  T & data_, 
  void (T::*fn_)(gobjContainer&) 
)
  { return new gobjcallbackcontainer<T>(data_,fn_); }



#endif