---

Scene.h

Go to the documentation of this file.

/*
    File:           Scene.h

    Function:       Basic definitions for a scene and its constituent objects:
                    attributes (for setting state variables such as colour),
                    primitives (drawing) and groups (aggregates of primitives).
                    
    Author(s):      Andrew Willmott

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

#ifndef __Scene__
#define __Scene__

#include "cl/ObjArray.h"
#include "gcl/Renderer.h"
#include "gcl/SLContext.h"

// --- Basic Object types -----------------------------------------------------


enum scAttributeID
{
// -- attributes -------//
    aState = 1,         // general state variables 
    aColour,            // a colour/reflectance value
    aEmittance,         // an emittance value

    aPoints,            // a list of points
    aColours,           // a list of colours
    aNormals,           // a list of normals
    aCoords,            // a list of texture coordinates

    aPointIndexes,      // indexes into a point list.
    aNormalIndexes,     // indexes into a normal list.
    aCoordIndexes,      // indexes into a coord list.
    aColourIndexes,     // indexes of vertex colour attributes.

    aFaceIndexes,       // list of index ranges per face
    aMeshType,          // are our faces polygons, triangle lists, tri strips...

    aTransform,         // a transformation
    aCamera,            // scene camera (i.e., projection kind)
    aTexture,           // scene texture map
    aObjHide,           // set if objects should be off
    aAvarList,          // a list of avar values
// -- end of list ------//
    aNumAttributes 
};

enum scPrimitiveID
{
// -- primitives -------//
    pGroup = 1,
    pPoly,
    pSphere,
    pCylinder,
    pCone,
    pTetrahedron,
    pMRModel, 
    pExtension, 
// -- end of list ------//
    pNumPrimitives
};

class Avar;

// --- Scene decimation -------------------------------------------------------

enum DecFlags
{
    DecTris             = 0x0001,       // triangulate polys
    DecQuads            = 0x0002,       // pass through parallelograms
    DecUseMaster        = 0x0004,       // generate a single, master point list
    DecIgnoreMRM        = 0x0008,       // ignore multiresolution models
    DecIsMRM            = 0x0010        // this is a mr model triangle
};

enum DecStatus
{
    DEC_Start           = -1,
    DEC_End             = -2
};

struct Decimator
{
    virtual Void    HandlePoly(
                        Int         numVertices,        // # vertices in this polygon
                        Int         vertices[],         // vertex indicies
                        Int         materialChanged     // has the material changed
                    ) = 0;

    Int             decNum;             // increases by 1 with each DecCallback
    Int             pointsAccNum;       // points offset
    Transform       transAcc;           // current model transform
    PointList       *pointsAcc;         // master points list if requested
    SLContext       *context;           // current context for this polygon
    Flags32         flags;
};

struct FindDecInfo : public Decimator
{
    Void    HandlePoly(Int numVerts, Int vertices[], Int materialChanged);

    Int     numTris;
    Int     numQuads;
    Int     numPolys;
    Int     numProps;
};


// --- Fundamental scene objects ----------------------------------------------

#define SO_GET(X) ((sc ## X *) Get(a ## X))     
// shorthand for fetch & cast attribute...

class scObject;
class scGroup;
class scSceneAction;
typedef scObject                    *scObjectPtr;

class scObject : public Object
{
public:
    
    scObject() :                    Object(), itsType(0) {};
    scObject(Int itsType) :         Object(), itsType(itsType) {};
    scObject(const scObject &so) :  Object(), itsType(so.itsType) {};
    virtual ~scObject();
    
    virtual Void            Apply(const Transform &m);
                            // Transform the object
    Void                    ApplyAction(scSceneAction &a);
                            // Apply action to object
    virtual Void            ApplyActionSelf(scSceneAction &a);
                            // Internal routine for the above.          
    Void                    Print(ostream &s) const;
    virtual Void            HierPrint(ostream &s, Int indent) const;
    
    Void                    Decimate(Decimator &dec, UInt32 flags);
    virtual Void            DecimateSelf(Decimator &dec) {};
        
    Object                  *Clone() const { return new scObject(SELF); };
    Bool                    IsPrim() const { return(itsType > 0); };
    Bool                    IsAttr() const { return(itsType < 0); };
    Bool                    IsGroup() const { return(itsType == pGroup); };
    scPrimitiveID           PrimID() const { return(scPrimitiveID) itsType; };
    scAttributeID           AttrID() const { return(scAttributeID) -itsType; };
    
protected:
    Int                     itsType;
                            // -ve == attribute, +ve == primitive.
    static Int              prIndent;
                            // indent in printing
};

#define PrimCast(x) ((scPrimitive *) (scObject *)  x)
#define AttrCast(x) ((scAttribute *) (scObject *)  x)
#define GroupCast(x) ((scGroup *) x)

class scAttribute : public scObject
{   
public:
    scAttribute(AttrType attrType) :        scObject(-attrType) {};
    scAttribute(const scAttribute &sa) :    scObject(sa) {};

    virtual Void            AddToContext(SLContext *context);
                            // Add this attribute to the context
    virtual Bool            HasAvar(Avar &avar, Int slot);
                            // returns true (and sets avar) if the attribute
                            // is avar-controlled.
    Void                    Print(ostream &s) const;
        
    Object                  *Clone() const { return new scAttribute(SELF); };
};

class scClearAttr : public scAttribute
// Signals end of influence of a particular attribute.
{   
public:
    scClearAttr(AttrType attrType) :        scAttribute(attrType) {};

    Void                    AddToContext(SLContext *context);

    Void                    Print(ostream &s) const;

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


class scPrimitive : public scObject, public Renderable
{   
public:

    scPrimitive(scPrimitiveID primType) :   scObject(primType), parent(0) {};
    scPrimitive(const scPrimitive &sp) :    scObject(sp), parent(sp.parent) {};

    Void                    Draw(Renderer &r);                  
    virtual Void            Draw(Renderer &r, SLContext *context);
    Void                    Print(ostream &s) const;

    Void                    Normalise();
                            // re-scale scene to fit in unit cube.
    Void                    FindBounds(Point &min,  Point &max);
    virtual Void            UpdateBounds(Point &min,  Point &max, 
                                         const Transform &t);

    Void                    Apply(const Transform &m);
    virtual Void            Set(scAttribute *sa);
    virtual scAttribute     *Get(scAttributeID id);
    virtual scAttribute     *FindFirst(scAttributeID id);
    
    virtual StrConst        Label() const { return "unknown primitive"; }; 
    Object                  *Clone() const { return new scPrimitive(SELF); };
    scGroup                 *parent;

    Void                    ExtDispatch(Int method, Void *data);
                            // for later extensions

    static RenderStyle      sRenderStyle;
    static Colour           sDefaultColour;

private:
    scPrimitive() {};
    Void                    *extData;
};


// --- Group object -----------------------------------------------------------


class scGroup : public scPrimitive
{
public:
    scGroup() : scPrimitive(pGroup), children(), 
                name("unknown") {};
    scGroup(StrConst name) :    scPrimitive(pGroup), children(), 
                name(name) {};
    scGroup(const scGroup &sg);
    
    Void                    Apply(const Transform &m);
    Void                    ApplyActionSelf(scSceneAction &a);  
    Void                    UpdateBounds(Point &min, Point &max,
                                         const Transform &t);

    Void                    Draw(Renderer &r, SLContext *context);
    Void                    Print(ostream &s) const;
    Void                    HierPrint(ostream &s, Int indent) const;
    Void                    Parse(istream &s);
    Void                    Set(scAttribute *sa);
    virtual scAttribute     *FindFirst(scAttributeID id);
    
    Void                    DecimateSelf(Decimator &dec);

    scObject                *Child(Int i) const 
                            { return((scObject *) children[i]); };
    Int                     NumChildren() const 
                            { return(children.NumItems()); };

    Void                    SetName(StrConst name);

    Void                    Add(scObject *so);
    scObject                *Last();
    StrConst                Label() const; 
    Object                  *Clone() const;
    
    String                  name;
    ObjArray                children;
};


// --- Typedefs ---------------------------------------------------------------


typedef scGroup                     scScene;
typedef scScene                     *scScenePtr;
typedef ObjArray                    scObjectList;

ostream &operator << (ostream &s, const scScenePtr scene);

// --- Actions ----------------------------------------------------------------

class scSceneAction
{
public:
    scSceneAction() : context(0) {};
    
    virtual Void    Start();
    virtual Void    Stop();

    virtual Void    Primitive(scPrimitive *sp);
    virtual Void    Attribute(scAttribute *sa);
                                                
    SLContext       *context;
    Transform       transAcc;   // XXX should be part of context one of these
                                // days
};

#endif

---