---

SceneObjects.h

Go to the documentation of this file.

/*
    File:           SceneObjects.h

    Function:       Contains definitions of the fundamental scene objects and 
                    their attributes.
                    
    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott
 */

#ifndef __SceneObjects__
#define __SceneObjects__

#include "gcl/Scene.h"
#include "gcl/SLContext.h"
#include "gcl/Renderer.h"
#include "gcl/Texture.h"


// --- Primitives -------------------------------------------------------------


class scPoly : public scPrimitive
// polygonal mesh
{
public:

    scPoly() : scPrimitive(pPoly) {};
    scPoly(const scPoly &sp) : scPrimitive(sp) {};

    Void                    Draw(Renderer &r, SLContext *context);
    StrConst                Label() const;
    Void                    Parse(istream &s);

    Void                    DecimateSelf(Decimator &dec);

    Object                  *Clone() const { return new scPoly(SELF); };
};


// --- Attributes -------------------------------------------------------------


class scColour : public scAttribute, public Colour
{
public: 
    scColour() : scAttribute(aColour), Colour() {};
    scColour(const Colour &c) : scAttribute(aColour), Colour(c) {};
    
    Void                    Print(ostream &s) const
                            { s << "colour " << (Colour &) SELF; };
    Void                    Parse(istream &s) 
                            { s >> (Colour &) SELF; };

    Object                  *Clone() const { return new scColour(SELF); };
};

class scTransform : public scAttribute, public Transform
{
public: 
    scTransform() : scAttribute(aTransform), Transform() {};
    scTransform(const Transform &t) : scAttribute(aTransform), Transform(t) {};
    
    Void                    Print(ostream &s) const
                            { s << "transform " << (Transform &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (Transform &) SELF; };

    Void                    ApplyActionSelf(scSceneAction &a);

    Object                  *Clone() const { return new scTransform(SELF); };
};

class scEmittance : public scAttribute, public Colour
{
public: 
    scEmittance() : scAttribute(aEmittance), Colour() {};
    scEmittance(const Colour &c) : scAttribute(aEmittance), Colour(c) {};
    
    Void                    Print(ostream &s) const
                            { s << "emittance " << (Colour &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (Colour &) SELF; };

    Object                  *Clone() const { return new scEmittance(SELF); };
};

class scPoints : public scAttribute, public PointList
{
public: 
    scPoints() : scAttribute(aPoints), PointList() {};
    scPoints(const PointList &pl) : scAttribute(aPoints), PointList(pl) {};
    
    Void                    Apply(const Transform &m);
    Void                    Print(ostream &s) const
                            { s << "points " << (PointList &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (PointList &) SELF; };
    
    Object                  *Clone() const { return new scPoints(SELF); };
};
 
class scCoords : public scAttribute, public CoordList
{
public: 
    scCoords() : scAttribute(aCoords), CoordList() {};
    scCoords(const CoordList &pl) : scAttribute(aCoords), CoordList(pl) {};
    
    Void                    Apply(const Transform &m);
    Void                    Print(ostream &s) const
                            { s << "coords " << (CoordList &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (CoordList &) SELF; };
    
    Object                  *Clone() const { return new scCoords(SELF); };
};

class scColours : public scAttribute, public ColourList
{
public: 
    scColours() : scAttribute(aColours) {};
    
    Void                    Print(ostream &s) const
                            { s << "colours " << (ColourList &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (ColourList &) SELF; };

    Object                  *Clone() const { return new scColours(SELF); };
};

class scNormals : public scAttribute, public VectorList
{
public: 
    scNormals() : scAttribute(aNormals) {};
    
    Void                    Print(ostream &s) const
                            { s << "normals " << (VectorList &) SELF; };
    Void                    Parse(istream &s)
                            { s >> (VectorList &) SELF; };

    Object                  *Clone() const { return new scNormals(SELF); };
};

class scIndexes : public scAttribute, public IndexList
{
public: 
    scIndexes(scAttributeID id) : 
                            scAttribute(id), IndexList() {};
    scIndexes(scAttributeID id, const IndexList &il) : 
                            scAttribute(id), IndexList(il) {};
    
    Void                    Print(ostream &s) const;
    Void                    Parse(istream &s)
                            { s >> (IndexList &) SELF; };

    Object                  *Clone() const 
                            { return new scIndexes(SELF); };
};

typedef scIndexes scPointIndexes;
typedef scIndexes scColourIndexes;
typedef scIndexes scNormalIndexes;
typedef scIndexes scCoordIndexes;
typedef scIndexes scFaceIndexes;

class scCamera : public scAttribute, public Camera
{
public:

    scCamera() : scAttribute(aCamera), Camera() {};
    scCamera(const Camera &c) : scAttribute(aCamera), Camera(c) {};

    Void                    Print(ostream &s) const;
    Void                    Parse(istream &s);

    Object                  *Clone() const { return new scCamera(SELF); };
};

class scTexture : public scAttribute, public Texture
{
public:

    scTexture() : scAttribute(aTexture), Texture() {};
    scTexture(const Texture &c) : scAttribute(aTexture), Texture(c) {};

    Void                    Print(ostream &s) const;
    Void                    Parse(istream &s);

    Object                  *Clone() const { return new scTexture(SELF); };
};
    
class scMeshType : public scAttribute
{
public:

    scMeshType() : scAttribute(aMeshType), itsType(renPoly) {};

    Void                    Print(ostream &s) const;
    Void                    Parse(istream &s);

    Object                  *Clone() const { return new scMeshType(SELF); };

    RenderStyle             itsType;
};

#endif

---