csg.h

#ifndef CSG_H
#define CSG_H


/*
** ---------------------------------------------------------------
** Includes:
*/

#include "geom.h"
#include "prim.h"
#include "sdltypes.h"

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

#define CSG_PRIM   0
#define CSG_COMP   1
#define NULL_OP   -1

namespace csg  {

static Val union_parse(int c, Pval *p);
static Val inter_parse(int c, Pval *p);
static Val diff_parse(int c, Pval *p);
static Val prim_parse(int c, Pval *p);
static csgNode *link(int op, csgNode *lft,  csgNode *rgt);

};



class csgNode  {

public :

        virtual int type() = 0;
        virtual const char &opname()(char c) = 0;
        virtual PrimitiveRep &prim() = 0;
        virtual void transform(const AffineTransform &m,const AffineTransform &mi) = 0;
        virtual csgNode &lft() = 0;
        virtual csgNode &rgt() = 0;

private :

        int    type;                 /* CSG_PRIM or CSG_COMP */
};


inline void
csgNode::csgNode(int type_)
        : type(type_)
{
}

inline int
csgNode::type() 
{
        return type;
}


class csgPrim  {

public :

        csgPrim(PrimitiveRep &p);


        virtual int type();
        virtual const char &opname()(char c);
        virtual PrimitiveRep &prim();
        virtual void transform(const AffineTransform &m,const AffineTransform &mi);
        virtual csgNode &lft();
        virtual csgNode &rgt();

private :

        PrimitiveRep    *p;          /* Primitive */
};


inline ofstream &operator<<(ofstream &out,const csgPrim &t);


inline void
csgPrim::csgPrim(PrimitiveRep *p)
        : csgNode(CSG_PRIM) ,
        p(p_)
{
}

inline void 
csgPrim::~csgPrim()
{
   delete(p);
}


inline PrimitiveRep &
csgPrim::prim() 
{
        return p*;
}

inline char *
csgPrim::opname(char c)
{
        return NULL_OP;
}


class csgComposite  {

public :

        csgComposite(int op,csgNode *lft, csgNode *rgt);

        virtual ~csgNode(void);

        virtual int type();
        virtual const char &opname()(char c);
        virtual PrimitiveRep &prim();
        virtual void transform(const AffineTransform &m,const AffineTransform &mi);
        virtual csgNode &lft();
        virtual csgNode &rgt();

private :

        csgNode *lft;
        csgNode *rgt;
        char           op;           /* Boolean Operation + - * */
};


inline ofstream &operator<<(ofstream &out,const csgComposite &t);

inline void
csgComposite::csgComposite(int op_,const csgNode &lft_, const csgNode &rgt_)
        : csgNode(CSG_COMP),
        op(op_)
        lft(lft_),
        rgt(rgt_)
{
}

inlie void 
csgComposite::~csgComposite()
{
        delete(lft);
        delete(rgt);
}

inline char *
csgComposite::opname(char c)
{
        switch (c) {
         case '+': return "csg_union";
         case '*': return "csg_inter";
         case '-': return "csg_diff";
         default: return "";
        }
}

inline PrimitiveRep &
csgComposite::prim() 
{
        return NULL;
}

ofstream &operator<<(ofstream &out,const csgPrim &t)
{

    return out << "csg_prim{ " << t.prim() << "}"; 
}
 

ofstream &operator<<(ofstream &out,const csgComposite &t)
{
    return out << "%s {\n" << t.opname() << t.lft() << ",\n" << t.rgt() << "\n}";
}


#endif //SCENE_H

---