SceneObject.h

#ifndef SCENE_OBJECT_H
#define SCENE_OBJECT_H


/*
** ---------------------------------------------------------------
** Includes:
*/
#include <vector>
#include "Vector3.h"
#include "AffineTransform.h"
#include "lang.h"


/*
** ---------------------------------------------------------------
** Definitions:
*/

typedef std::vector<SceneObject *> SceneObjects;


class SceneObject  {

public :

        SceneObject(int type,const Material &mat);

        virtual ~SceneObject();
        
        const Material &material();

        const int type();

        virtual void transform(const AffineTransform &m,const AffineTransform &mi) = 0;
        static Val parse(int c, Pval *pl);
                
private :

        Material *mat = new Material();
        int   type;
}; 



class ShapeObject : SceneObject {

public :

        ShapeObject(const Material &mat,const PolygonArray &shape);

        virtual ~ShapeObject();
        
        virtual void transform(const AffineTransform &m,const AffineTransform &mi);
                
private :

        PolygonArray &shape;
}; 

inline void
ShapeObject::ShapeObject(const Material &mat,const PolygonArray &shape_) 
        : SceneObject(SHAPE_OBJ,mat),
        shape(shape_)
{
}

inline void
ShapeObject::transform(const AffineTransform &m,const AffineTransform &mi)
{
        PolygonArray::<iterator *> it;
        for (it.begin();!it.end();it++) {

                Polygon *p = it*;
                p->transform(m,mi);
        }
}
                



class PrimObject  {

public :

        PrimObject(const Material &mat,const PrimitiveRep &prim);

        ~PrimObject();
        
        virtual void transform(const AffineTransform &m,const AffineTransform &mi);
                
private :

        PrimitiveRep &prim;
}; 

inline void
PrimObject::PrimObject(const Material &mat,const PrimitiveRep &prim_) 
        : SceneObject(PRIM_OBJ,mat),
        prim(prim_)
{
}

inline void
PrimObject::transform(const AffineTransform &m,const AffineTransform &mi)
{
        prim.transform(m,mi);
}




class csgNodeObject  {

public :

        csgNodeObject(const Material &mat,const csgNode *root);

        ~csgNodeObject();
        
        virtual void transform(const AffineTransform &m,const AffineTransform &mi);
        static Val parse(int c, Pval *pl);
                
private :
        csgNode *root;
}; 


inline void
csgNodeObject::csgNodeObject(const Material &mat,const csgNode *root_) 
        : SceneObject(CSG_OBJ,mat),
        root(root_)
{
}

inline void
csgNodeObject::transform(const AffineTransform &m,const AffineTransform &mi)
{
        root->transform(m,mi);
}

#endif //SCENE_OBJECT_H

---