---

Scene.cc

Go to the documentation of this file.

/*
    File:           Scene.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          

*/

#include "gcl/Scene.h"
#include "gcl/Avars.h"
#include <iomanip.h>
#include "gcl/VecUtil.h"
#include "gcl/SceneObjects.h"
#include "gcl/ParseSL.h"

//  'gAttributeNameTable' is a Table for the names of the various attributes.
//  Should be more extendable than this...

Char *gAttributeNameTable[] =
{
    "State",
    "Colour",
    "Emittance",

    "Points",
    "Colours",
    "Normals",
    "Texture Coordinates",

    "Point Indexes",
    "Colour Indexes",
    "Normal Indexes",
    "TexCoord Indexes",

    "Faces",
    "Mesh Type",

    "Transformation",
    "Camera",
    "Texture",
    "ObjHide",
    "Avar List",
    0
};


/*
  Notes on polygonal data:

  The scene format is made up of a number of layers, with defaults

  points/colours/normals lists: contain the actual data.

  if there exist indexes/cindexes/nindexes lists, these contain indices
  into the most recent entity lists; if not, the indexes are assumed to
  read 1, 2, 3, ...

  if there is a faces list, it is assumed to define polygonal faces by
  the range of indices into the indexes lists. If not, the lists are
  assumed to define a single face.

  (i)   points a, b, c
        points c, d, a

  (ii)  points a, b, c, d
        indexes 0, 1, 2
        indexes 2, 3, 0

  (iii) points a, b, c, d
        indexes 0, 1, 2, 2, 3, 0
        faces 0,3,6

  for this trivial example, (ii) and (iii) might not seem that useful. For
  a large model, with a number of different vertex properties (points, 
  surface normals, texture coordinates, etc.) they provide more
  flexibility and space savings.

*/


// --- scObject methods -------------------------------------------------------


scObject::~scObject()
{
}

Void scObject::Apply(const Transform &m)
{
}

Void scObject::ApplyAction(scSceneAction &a)
{   
    a.Start();
    ApplyActionSelf(a);
    a.Stop();
}

Void scObject::ApplyActionSelf(scSceneAction &a)
{   
    if (IsAttr())
        a.Attribute(AttrCast(this));
    else if (IsPrim())
        a.Primitive(PrimCast(this));
}

Void scObject::Print(ostream &s) const
{
    s << "Undefined object";
}

Void scObject::HierPrint(ostream &s, Int indent) const
{
    Int i;
    
    for (i = 0; i < indent; i++)
        s << ' ';
        
    Print(s);
    
    s << endl;
}

Void scObject::Decimate(Decimator &dec, UInt32 flags)
{
    SLContext       context(aNumAttributes);

    dec.decNum = 0;
    dec.pointsAccNum = 0;
    dec.transAcc = vl_I;
    dec.flags.Clear();
    dec.flags.Set(flags);
    dec.context = &context;

    if (flags & DecUseMaster)
        dec.pointsAcc = new PointList;
    else
        dec.pointsAcc = 0;

    dec.HandlePoly(DEC_Start, 0, false);
    DecimateSelf(dec);
    dec.HandlePoly(DEC_End, 0, false);
}


// --- Printing operator ------------------------------------------------------


Int scObject::prIndent = 4;

ostream &operator << (ostream &s, const scScenePtr scene)
{
    scene->HierPrint(s, 0); // Start from 0 indentation
    
    return(s);
}


// --- scAttribute methods ----------------------------------------------------


Void scAttribute::Print(ostream &s) const
{
    s << "set " << gAttributeNameTable[AttrID()] << " [" << (Int) AttrID() << "]";
}

Void scAttribute::AddToContext(SLContext *context)
{
    context->Set(AttrID(), this);
}

Bool scAttribute::HasAvar(Avar &avar, Int slot)
{
    return(false);
}

#ifdef UNFINISHED
Bool scAttribute::HasAvars(Avar &avar, Int slot)
{
    rotSlot = list.RegisterAvar("rotate_c");
    list.RegisterAvar("rotate_c");
    list.RegisterAvar("rotate_c");
    return(false);
}
#endif

Void scClearAttr::Print(ostream &s) const
{
    s << "clear " << gAttributeNameTable[AttrID()] << " [" 
      << (Int) AttrID() << "]";
}

Void scClearAttr::AddToContext(SLContext *context)
{
    context->Set(AttrID(), 0);
}


// --- scPrimitive methods ----------------------------------------------------


RenderStyle scPrimitive::sRenderStyle = renPoly;
Colour scPrimitive::sDefaultColour(cOrange);

Void scPrimitive::Draw(Renderer &r)
{
    SLContext context(aNumAttributes);

    context.Clear();

    Draw(r, &context);
}

Void scPrimitive::Draw(Renderer &r, SLContext *context)
{
}

Void scPrimitive::Print(ostream &s) const
{
    s << Label();
}

Void scPrimitive::Apply(const Transform& m)
{
}

Void scPrimitive::Set(scAttribute *sa)
{
    Assert(false, "can't set attribute of a non-group.");
    if (parent)
    {
        Int i;

        for (i = 0; i < parent->NumChildren(); i++)
            if (parent->Child(i) == this)
            {
                parent->children.Insert(i, sa);
                return;
            }

        _Error("Bad parent pointer...");
    }
    else
        Assert(false, "can't set attribute of a parentless primitive.");
}

scAttribute *scPrimitive::Get(scAttributeID searchID)
{
    Int i;
    scAttribute *result = 0;
    
    if (parent == 0)
        return(0);
        
    for (i = 0; i < parent->NumChildren(); i++)
        if (parent->Child(i)->AttrID() == searchID)
            result = AttrCast(parent->Child(i));
        else if (parent->Child(i) == this)
            break;
    
    if (result == 0)
        return(parent->Get(searchID));  
    else
        return(result);
}

scAttribute *scPrimitive::FindFirst(scAttributeID id)
{
    return(0);
}

Void scPrimitive::Normalise()
{
    Point   min, max;
    GCLReal scale;
    Vector  centre; 

    // scale so longest dimension is 1
    // center on y axis such that bottom of object touches z-x plane.

    FindBounds(min, max);
    scale = MaxElt(max - min) / 2.0;
    centre = (min + max) * 0.5;
    centre[vl_y] -= (max[vl_y] - min[vl_y]) * 0.5;
    Apply(xform(Scalef(1.0 / scale), Shift(-centre)));
}

Void scPrimitive::FindBounds(Point &min, Point &max)
{
    min.MakeBlock(HUGE_VAL);
    max.MakeBlock(-HUGE_VAL);
    UpdateBounds(min, max, vl_I);
}

Void scPrimitive::UpdateBounds(Point &min, Point &max,
                               const Transform &t)
{
}

Void scPrimitive::ExtDispatch(Int method, Void *data)
{
    if (method == -1)
        cerr << "ExtDispatch called, data = " << data << endl;
}

// --- scGroup methods --------------------------------------------------------

scGroup::scGroup(const scGroup &sg) : 
    scPrimitive(sg), 
    children(sg.children),
    name(sg.name)
{
    int i;
    
    for (i = 0; i < children.NumItems(); i++)
        if (Child(i)->IsPrim())
            PrimCast(Child(i))->parent = this;
}

Void scGroup::ApplyActionSelf(scSceneAction &a)
{   
    if (a.context->Get(aObjHide)) return;

    Int         i;
    Transform   saveAcc;

    a.context->Push();
    saveAcc = a.transAcc;

    for (i = 0; i < NumChildren(); i++)
        Child(i)->ApplyActionSelf(a);

    a.transAcc = saveAcc;
    a.context->Pop();
}

Void scGroup::Apply(const Transform &m)
{
    children.Prepend(new scTransform(m));
}

Void scGroup::UpdateBounds(Vector &min, Vector &max, 
                           const Transform &transform)
{
    Int         i, j;
    Transform   groupTransform(transform);

    // should change this to call attr->UpdateBounds?
    
    for (i = 0; i < NumChildren(); i++)
        if (Child(i)->IsAttr())
        {
            if (Child(i)->AttrID() == aTransform)
            {
                groupTransform = xform(groupTransform,
                                       (scTransform &) *AttrCast(Child(i)));
            }
            else if (Child(i)->AttrID() == aPoints)
            {
                PointList *pl = (scPoints*) AttrCast(Child(i));
                for (j = 0; j < pl->NumItems(); j++)
					::UpdateBounds(xform(groupTransform, (*pl)[j]), min, max);
            }
        }
        else
            PrimCast(Child(i))->UpdateBounds(min, max, groupTransform);
}

Void scGroup::SetName(StrConst newName)
{
    name = newName;
}

Void scGroup::Add(scObject *so)
{
    if (so->IsPrim())
        PrimCast(so)->parent = this;
    children.Append(so);
}

scObject *scGroup::Last()
{
    return((scObject *) children.Top());
}

StrConst scGroup::Label() const
{
    return(name);
}

Void scGroup::Print(ostream &s) const
{
    HierPrint(s, 0);    // Start from 0 indentation
}

Void scGroup::DecimateSelf(Decimator &dec)
{
    if (dec.context->Get(aObjHide)) return;

    Int         i, j, k, savePointsAccNum;
    Transform   saveTransAcc;

    // push current state.
    dec.context->Push();
    saveTransAcc = dec.transAcc;
    savePointsAccNum = dec.pointsAccNum;

    for (i = 0; i < NumChildren(); i++)
        if (Child(i)->IsPrim())
            PrimCast(Child(i))->DecimateSelf(dec);
        else
        {
            AttrCast(Child(i))->AddToContext(dec.context);

            if (Child(i)->AttrID() == aPoints && (dec.flags.IsSet(DecUseMaster)))
            {
                PointList   *points;
            
                // need to append this to the master points list
                points = (scPoints*) AttrCast(Child(i));
                // save the current end of the list as the new numbering
                // offset.
                dec.pointsAccNum = dec.pointsAcc->NumItems();
                dec.pointsAcc->Add(points->NumItems());
                // apply the current model transform to the new points
                k = dec.pointsAccNum;
                for (j = 0; j < points->NumItems(); j++)
                    (*dec.pointsAcc)[k++] = xform(dec.transAcc,
                                                     (*points)[j]);
            }
            else
            {
                // if it's a transform, concatenate it to transAcc
                if (Child(i)->AttrID() == aTransform)
                    dec.transAcc = xform(dec.transAcc,
                        *(scTransform*)(dec.context->Get(aTransform)));
            }
        }

    // pop current state.
    dec.context->Pop();
    dec.transAcc = saveTransAcc;
    dec.pointsAccNum = savePointsAccNum;
}

Void scGroup::HierPrint(ostream &s, Int indent) const
{   
    Int     i, j;

    for (j = 0; j < indent; j++)
        s << ' ';
    s << "object \"";
    if (name) 
        s << name;
    s << "\"" << endl; // " << (Void *) this << ' ' << (Void *) parent << endl; 
    
    for (i = 0; i < NumChildren(); i++)
        Child(i)->HierPrint(s, indent + prIndent);
        
    for (j = 0; j < indent; j++)
        s << ' ';

    s << "end" << endl;
}


Void scGroup::Parse(istream &s)
{
    Char        c;
    scObject    *newObj;
    String      *str = new String;
        
    while (isspace(s.peek()))               //  chomp white space
        s.get(c);
        
    s >> *str;
    *str = SubstituteEnvVars(*str);

    name = str->Ref();
    
    children.Clear();
        
    while (1)
    {           
        newObj = ParseSLObject(s);
        if (newObj == 0)
            break;
        if (!s)
        {
            Expect(false, "Couldn't read object component");
            return;
        }

        Add(newObj);
    }           
}

Object *scGroup::Clone() const
{
    Int i;
    scGroup *result;
        
    result = new scGroup(name);
    
    for (i = 0; i < children.NumItems(); i++)
        result->Add((scObject*) children[i]->Clone());
                
    return(result);
}

#include "gcl/SceneObjects.h"

Void scGroup::Draw(Renderer &r, SLContext *context)
{
    if (context->Get(aObjHide)) return;

    Int     i;
    
    r.Push();
    context->Push();
    
    for (i = 0; i < NumChildren(); i++)
        if (Child(i)->IsPrim())
            PrimCast(Child(i))->Draw(r, context);
        else
        {
            // ignore cameras other than the first one
            if (Child(i)->AttrID() == aCamera && context->Get(aCamera))
                continue;

            AttrCast(Child(i))->AddToContext(context);
            if (Child(i)->AttrID() == aTransform)
                r.SetTransform((scTransform &) *AttrCast(Child(i)));
            else if (Child(i)->AttrID() == aCamera)
                r.SetCamera((scCamera &) *AttrCast(Child(i)));
        }
            
    context->Pop();
    r.Pop();
}

Void scGroup::Set(scAttribute *sa)
{
    Int     i;

#ifdef UNFINISHED
    for (i = 0; i < NumChildren() && Child(i)->IsAttr(); i++)
        if (Child(i)->AttrID() == sa->AttrID())
        {
            Child(i)->Free();
            children[i] = sa;
            return;
        }
#endif
        
    children.Prepend(sa);
}

scAttribute *scGroup::FindFirst(scAttributeID id)
{
//  if (!on) return(0); XXX
    
    Int         i;
    scAttribute *result;
    
    for (i = 0; i < NumChildren(); i++)
        if (Child(i)->IsPrim())
        {
            result = PrimCast(Child(i))->FindFirst(id);
            if (result)
                return(result);
        }
        else if (Child(i)->AttrID() == id)
                return(AttrCast(Child(i)));
                
    return(0);
}

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


Void scSceneAction::Start()
{
    transAcc = vl_I;
    context = new SLContext(aNumAttributes);
}

Void scSceneAction::Stop()
{
    delete context;             
    context = 0;
}

Void scSceneAction::Primitive(scPrimitive *sp)
{
}

Void scSceneAction::Attribute(scAttribute *sa)
{
    sa->AddToContext(context);
}


// --- Avar methods/operators -------------------------------------------------


ostream  &operator << (ostream &s, const Avar &avar)
{
    s << avar.name << " [" << avar.lowerBound << " " << avar.value << " " <<
        avar.upperBound << "]";
    
    return(s);
}


// --- extras -----------------------------------------------------------------

Void FindDecInfo::HandlePoly(
        Int         numVertices,
        Int         vertices[],
        Int         changed
    )
{   
    if (numVertices == DEC_Start)
    {
        numProps = 0;
        numTris = 0;
        numQuads = 0;
        numPolys = 0;
    }
    
    if (numVertices < 0) return;

    if (changed)
        numProps++;
    
    if (numVertices == 3)
        numTris++;
    else if (numVertices == 4)
        numQuads++;

    numPolys++;
}

---