---

ParseSL.cc

Go to the documentation of this file.

/*
    File:       ParseSL.cc

    Function:   Parser for GCL's scene language

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/ParseSL.h"
#include "gcl/Readers.h"
#include "gcl/SceneObjects.h"
#include "gcl/Avars.h"
#include "gcl/SceneLang.h"
#include "gcl/PolyLib.h"

#define INFO_COUT cerr


// --- SL Parser --------------------------------------------------------------

// this is GCL's native scene language.

static FileName gSLReadPath;

struct SLParseState
{
    FileName    readPath;
    Int         version;
};

const Int SL_CURRENT_VERSION = 3;

scObject *ParseSLObject(istream &s)
// XXX Need to tokenize using a Hash sometime. This is tres inefficient...
{
    String      str;
    scObject    *object;
    Vector      v;
    GCLReal     r;

    // get next 'token'
    str.ReadWord(s);

    // handle comments
    while (str[0] == '#')
    {
        str.ReadLine(s);
        if (!s)
            return(0);
        str.ReadWord(s);
    }

    // attributes
    if (str == "camera")
        object = new scCamera;
    else if (str == "texture")
        object = new scTexture;
    else if (str == "avar")
    {
        str.ReadWord(s);
        
        if (str == "colour" || str == "reflectance")
            object = new scAvarColour(Avar("dummy"), vl_z);
        else if (str == "emittance")
            object = new scAvarEmittance(Avar("dummy"), vl_z);
        else if (str == "shift")
            object = new scAvarShift(Avar("dummy"), vl_z);
        else if (str == "rotate")
            object = new scAvarRotation(Avar("dummy"), vl_z);
        else if (str == "scale")
            object = new scAvarScale(Avar("dummy"), vl_z);
        else if (str == "scalef")
            object = new scAvarScalef(Avar("dummy"));
        else if (str == "switch")
            object = new scAvarSwitch(Avar("dummy"));
        else
        {
            INFO_COUT << "Unknown avar type: " << str << endl;
            return(0);
        }
    }
    else if (str == "points")
        object = new scPoints;
    else if (str == "coords")
        object = new scCoords;
    else if (str == "colours")
        object = new scColours;
    else if (str == "normals")
        object = new scNormals;

    else if (str == "indexes" || str == "vertices")
        object = new scIndexes(aPointIndexes);
    else if (str == "surfaces" || str == "s_indexes" || str == "c_indexes")
        object = new scIndexes(aColourIndexes);
    else if (str == "n_indexes")
        object = new scIndexes(aNormalIndexes);
    else if (str == "t_indexes")
        object = new scIndexes(aCoordIndexes);
    else if (str == "faces")
        object = new scIndexes(aFaceIndexes);
    else if (str == "face")
    {
        // XXX face [i1 i2 i3] (-normals [])...
    }

    else if (str == "colour" || str == "reflectance")
        object = new scColour;
    else if (str == "emittance")
        object = new scEmittance;

    // transforms
    else if (str == "transform")
        object = new scTransform;
    else if (str == "shift")
    {
        object = new scTransform;
        s >> v;
        *(scTransform*) object = Shift(v);
        return(object);
    }
    else if (str == "rotate")
    {
        object = new scTransform;
        s >> v >> r;
        *(scTransform*) object = Rotation(v, DegsToRads(r));
        return(object);
    }
    else if (str == "scale")
    {
        object = new scTransform;
        s >> v;
        *(scTransform*) object = Scale(v);
        return(object);
    }
    else if (str == "scalef")
    {
        object = new scTransform;
        s >> r;
        *(scTransform*) object = Scale(Vector(r, r, r));
        return(object);
    }
    else if (str == "set")
    {
        // XXX should set rendering state info at some stage. at the
        // moment we just have this hardcoded monstrosity
        str.ReadWord(s);
        if (str == "tesselation")
            s >> PolyLib::numTesselations;
        else
            INFO_COUT << "unrecognized variable " << str << endl;
        
        str.ReadLine(s);
        return(ParseSLObject(s));
    }

    // primitives
    else if (str == "poly" || str == "polys" || str == "mesh")
        object = Clone(slGetLibrary()->Member("poly"));
    else if (str == "object")
        object = Clone(slGetLibrary()->Member("group"));
    else if (str == "end")
        return(0);
    // external scene files
    else if (str == "coloursfile")
    {
        scColours  *clrs = new scColours;
        str.ReadString(s);
        clrs->ReadFile(str);
        return(clrs);
    }
    else if (str == "objectfile")
    {
        scScenePtr  scene;
        FileName    filename(gSLReadPath);

        str.ReadString(s);
        filename.SetRelPath(SubstituteEnvVars(str));
        INFO_COUT << "including " << filename.GetPath() << endl;
        scene = SceneReader::Load(filename);
        if (scene)
        {
            while (!IsEndOfLine(s))
            {
                str.ReadWord(s);
                if (str == "-zy" || str == "-zup")
                    scene->Apply(Rotation(vl_x, -vl_halfPi));
                else if (str == "-unit")
                    scene->Normalise();
                else
                    INFO_COUT << "objectfile: unrecognized option: " 
                              << str << endl;
            }
            return(scene);
        }
        else
        {
            str.ReadLine(s);
            return(ParseSLObject(s));
        }
    }   
    // add object definition to library
    else if (str == "define")
    {
        scGroup *group;
        
        group = (scGroup *) Clone(slGetLibrary()->Member("group"));
        group->Parse(s);
        slGetLibrary()->AddMember(group);

        return(ParseSLObject(s));
    }
    // retrieve object from library
    else if (object = slGetLibrary()->Member(str))
    {
        object = Clone(object);
        if (!object->IsGroup())
            object->Parse(s);
        return(object);
    }
    // give up.
    else
    {
        INFO_COUT << "Unknown token: " << str << endl;
        return(0);
    }
    
    object->Parse(s);
        
    return(object);
}

scScenePtr ParseSLFile(const Char *filename)
{
    ifstream        inFile;
    scScenePtr      result;
    FileName        savePath;
    SLParseState    state;

    inFile.open(filename);
    if (!inFile)
    {
        INFO_COUT << "Couldn't read file " << filename << endl;
        return(0);
    }

    savePath = gSLReadPath;
    gSLReadPath.SetPath(filename);
//  state.readPath.SetPath(filename);
//  state.version = SL_CURRENT_VERSION;
    result = (scScenePtr) ParseSLObject(inFile);
    gSLReadPath = savePath;

    inFile.close();
    return(result);
}

---