---

SceneLang.cc

Go to the documentation of this file.

/*
    File:           SceneLang.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          

*/


#include "gcl/SceneLang.h"
#include "gcl/SLContext.h"
#include "gcl/Readers.h"


// --- Current library & scene-parsing context --------------------------------

#ifdef UNFINISHED
class SLC
{
    static SLContext *slContext = new SLContext(aNumAttributes);
    static SLLibrary *slLibrary = 0;
    static scGroup *slCurrentGroupPtr;
};
#endif

static SLContext *slContext = new SLContext(aNumAttributes);
static SLLibrary *slLibrary = 0;
static scGroup *slCurrentGroupPtr;

// --- Scene command definitions ----------------------------------------------

Void slInit()
{
    slSetLibrary(new SLLibrary);
}

scObject *slCurrent()
{
    return(slCurrentGroupPtr->Last());
}

scScenePtr slCurrentGroup()
{
    return(slCurrentGroupPtr);
}
 
scScenePtr slBeginObject(const Char *name)
{
    if (slLibrary == 0)
    {
        cerr << "GCL Error in slBeginObject: slInit() was not called." << endl;
        exit(1);
    }
    
    scScenePtr  newGroup = GroupCast(Clone(slLibrary->Member("group")));
    
    newGroup->SetName(name);
            
    if (slCurrentGroupPtr)
        slCurrentGroupPtr->Add(newGroup);
    
    slCurrentGroupPtr = newGroup;
    slContext->Push();

    return(newGroup);
}

Void slEndObject()
{
    slCurrentGroupPtr = slCurrentGroupPtr->parent;
    slContext->Pop();   
}


// --- Attribute routines -----------------------------------------------------


Void slPointList()
{
    scPoints    *points = new scPoints;
    
    points->AddToContext(slContext);
    slCurrentGroupPtr->Add(points);
}

Int slPoint(const Point &p)
{
    scPoints    *points = SL_GET(Points);
        
    if (!points)
    {
        slPointList();
        points = (scPoints*) slCurrent();
    }
        
    points->Append(p);

    return(points->NumItems() - 1);
}

Void slPoints(const PointList &pl)
{
    scPoints    *points = new scPoints(pl);

    slCurrentGroupPtr->Add(points);
    points->AddToContext(slContext);
}

Void slColourList()
{
    scColours   *colours = new scColours;

    colours->AddToContext(slContext);
    slCurrentGroupPtr->Add(colours);
}

Int slColour(const Colour &c)
// XXX this is overloaded -- have slColour as vertex colour, and
// define different colour type as object colours (slDiffColour?)
{
    scColours   *colours;
        
    if (colours = SL_GET(Colours))
    {
        colours->Append(c);
        return(colours->NumItems() - 1);
    }
    else 
    {
        scColour    *colour = new scColour(c);

        slCurrentGroupPtr->Add(colour);
        colour->AddToContext(slContext);
        return(-1);
    }
}

Void slNormalList()
{
    scNormals   *normals = new scNormals;

    normals->AddToContext(slContext);
    slCurrentGroupPtr->Add(normals);
}

Int slNormal(const Vector &p)
{
    scNormals   *normals = SL_GET(Normals);
        
    if (!normals)
    {
        slNormalList();
        normals = (scNormals*) slCurrent();
    }
        
    normals->Append(p);

    return(normals->NumItems() - 1);
}

Void slCoordList()
{
    scCoords    *coords = new scCoords;

    coords->AddToContext(slContext);
    slCurrentGroupPtr->Add(coords);
}

Int slCoord(const Coord &c)
{
    scCoords    *coords = SL_GET(Coords);
        
    if (!coords)
    {
        slCoordList();
        coords = (scCoords*) slCurrent();
    }
        
    coords->Append(c);

    return(coords->NumItems() - 1);
}

Void slCoords(const CoordList &cl)
{
    scCoords    *coords = new scCoords(cl);

    slCurrentGroupPtr->Add(coords);
    coords->AddToContext(slContext);
}

// --- Index types -------------------------------------------------------

// Generic

Void slIndexList(scAttributeID id)
{
    scIndexes   *indexes = new scIndexes(id);

    indexes->AddToContext(slContext);
    slCurrentGroupPtr->Add(indexes);
}

Void slIndex(scAttributeID id, Int i)
{
    Assert(i >= 0, "(slIndex) negative index!");
    
    scIndexes   *indexes = (scIndexes*) slContext->Get(id);
    
    if (!indexes)
    {
        slIndexList(id);
        indexes = (scIndexes*) slCurrent();
    }

    indexes->Append(i);
}

Void slIndexes(scAttributeID id, const IndexList &il)
{
    scIndexes   *indexes = new scIndexes(id, il);

    slCurrentGroupPtr->Add(indexes);
    indexes->AddToContext(slContext);
}

// Specific

Void slPointIndexList() { slIndexList(aPointIndexes); }
Void slColourIndexList() { slIndexList(aColourIndexes); }
Void slNormalIndexList() { slIndexList(aNormalIndexes); }
Void slCoordIndexList() { slIndexList(aCoordIndexes); }

Void slPointIndex(Int i) { slIndex(aPointIndexes, i); }
Void slColourIndex(Int i) { slIndex(aColourIndexes, i); }
Void slNormalIndex(Int i) { slIndex(aNormalIndexes, i); }
Void slCoordIndex(Int i) { slIndex(aCoordIndexes, i); }

Void slPointIndexes(const IndexList &il) { slIndexes(aPointIndexes, il); }
Void slColourIndexes(const IndexList &il) { slIndexes(aColourIndexes, il); }
Void slNormalIndexes(const IndexList &il) { slIndexes(aNormalIndexes, il); }
Void slCoordIndexes(const IndexList &il) { slIndexes(aCoordIndexes, il); }

// ----------------------------------------------------------------------------

Void slTexture(StrConst filename)
{
    scTexture   *texture = new scTexture;

    texture->Load(filename);

    slCurrentGroupPtr->Add(texture);
    texture->AddToContext(slContext);
}

Void slCamera()
{
    scCamera *camera = new scCamera;
    
    camera->AddToContext(slContext);
    slCurrentGroupPtr->Add(camera);
}

Void slTransform(const Transform &t)
{
    scTransform *transform = new scTransform(t);

    slCurrentGroupPtr->Add(transform);
    transform->AddToContext(slContext);
}

Void slEmittance(const Colour &c)
{
    scEmittance *emit = new scEmittance(c);

    slCurrentGroupPtr->Add(emit);
    emit->AddToContext(slContext);
}

Void slPoly()
{
    scPrimitive *poly;
    
    poly = Clone(slLibrary->Member("poly"));

    slCurrentGroupPtr->Add(poly);
}

Void slBeginFaces()
{
    scIndexes   *indexes = SL_GET(PointIndexes);
    scIndexes   *faceIndexes = new scIndexes(aFaceIndexes);
    
    if (!indexes)
    {
        slPointIndexList();
        indexes = (scIndexes*) slCurrent();
    }

    faceIndexes->AddToContext(slContext);
    slCurrentGroupPtr->Add(faceIndexes);
    faceIndexes->Append(indexes->NumItems());
}

Void slFace()
{
    scIndexes       *faceIdxs = SL_GET(FaceIndexes);
    scIndexes       *idxs = SL_GET(PointIndexes);

    if (!faceIdxs)
        _Warning("slFace() without an slBeginFaces()");
    else
        faceIdxs->Append(idxs->NumItems());
}

Void slEndFaces()
{
    scIndexes       *faceIdxs = SL_GET(FaceIndexes);

    if (!faceIdxs)
        _Warning("slFace() without an slBeginFaces()");
    else if (faceIdxs->NumItems() > 1)
        slPoly();
    // XXX else remove empty face list.
}

// --- Generic ----------------------------------------------------------------

Void slApply(const Transform &t)
{
    slCurrent()->Apply(t);
}

Bool slObjectExists(const Char *name)
{
    if (slLibrary)
        return(slLibrary->MemberExists(name));
    else
        return(false);
}

scPrimitive *slObject(const Char *name)
{
    scPrimitive *newObj = Clone(slLibrary->Member(name));
    
    slCurrentGroupPtr->Add(newObj);

    return(newObj);
}

scPrimitive *slObject(scPrimitive *object)
{
    slCurrentGroupPtr->Add(object);
    return(object);
}

scPrimitive *slObjectFile(StrConst filename)
{
    scScenePtr  scenePtr;
    FileName    sceneFile;
    
    sceneFile.SetPath(SubstituteEnvVars(filename));
    scenePtr = SceneReader::Load(sceneFile);

    if (scenePtr)
        slCurrentGroupPtr->Add(scenePtr);

    return(scenePtr);
}

Void slBeginObject(scScenePtr object)
{
    if (slCurrentGroupPtr)
        slCurrentGroupPtr->Add(object);
    
    slCurrentGroupPtr = object;
    slContext->Push();
}

Void slAttribute(scAttribute *attrPtr)
{
    slCurrentGroupPtr->Add(attrPtr);
    attrPtr->AddToContext(slContext);
}

Void slEndAttribute(Int attr)
{
    slCurrentGroupPtr->Add(new scClearAttr(attr));
}

Void slMeshType(RenderStyle renStyle)
{
    scMeshType *sm = new scMeshType;

    sm->itsType = renStyle;
    slCurrentGroupPtr->Add(sm);
}

SLContext *slGetContext()
{
    return(slContext);
}

// --- Library routines -------------------------------------------------------


Void slSetLibrary(SLLibrary *library)
{
    delete slLibrary;
    
    slLibrary = library;
    slLibrary->Create();
}

SLLibrary *slSwapLibrary(SLLibrary *newLib)
{
    SLLibrary *tl = slLibrary;
    
    slLibrary = newLib;
    return(tl);
}

Void slAddToLibrary(scGroup *newGroup)
{
    slLibrary->AddMember(newGroup);
}

SLLibrary *slGetLibrary()
{
    return(slLibrary);
}

---