---

SLRender.cc

Go to the documentation of this file.

/*
    File:       SLRender.cc

    Function:   

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/GCLConfig.h"

#ifdef GCL_MESA
#include "cl/ArgParse.h"

#include "gcl/GCLApp.h"
#include "gcl/MesaRenderer.h"
#include "gcl/Readers.h"

#define DBG_COUT if (0) cerr


// --- RenderApp --------------------------------------------------------------


class RenderApp : public GCLApp
{
public:

    Void            SetOptions(Int argc, Char **argv);
    Int             Run();
    Void            DrawScenes();
    
// options
    Char            *output;
    Int             wireFrame;
    Int             window;

    StrConst        animFile;
    Int             startFrame;
    Int             endFrame;
    Int             frameStep;
    Int             noLight;
    Int             showBF;
    Int             super;
};

Void RenderApp::SetOptions(Int argc, Char **argv)
{
    ArgForm     *arg_format;
    Double      grey, clr[3], defClr[3];
    Int         formats;
    Int         size;
    
    size = 400;
    xsize = -1;
    ysize = -1;
    output = 0;
    grey = 0.5;
    clr[0] = -1;
    defClr[0] = -1;
    animFile = 0;
    startFrame = -1;
    endFrame = -1;
    frameStep = 1;
    
    arg_format = arg_to_form(0,
        "", 
            "Usage: slview file1 file2 ... [options]",
        "", ARG_SUBR(GetFileArgs), 
            "",
        "-o %S", &output,
            "Set output file",
        "-bgr %F", &grey,
            "Set background grey level",
        "-bgc %F %F %F", clr, clr + 1, clr + 2, 
            "Set colour background",
        "-defClr %F %F %F", defClr, defClr + 1, defClr + 2, 
            "Set default model colour",
        "-noScale", ARG_FLAG(&noScale),
            "Don't rescale scene.",
        "-wire", ARG_FLAG(&wireFrame),
            "Draw wire-frame.",
        "-zup", ARG_FLAG(&zUp),
            "Z axis is up (default is Y)",
        "-zdown", ARG_FLAG(&zDown),
            "Z axis is down",
        "-noLight", ARG_FLAG(&noLight),
            "no lighting",
        "-showBF", ARG_FLAG(&showBF),
            "show back faces of polygons",
        "-super", ARG_FLAG(&super),
            "supersample",

        "-anim %S",     &animFile,                  "specify animation file",
        "-fps %F",      &fps,                       "set frames per sec [default 24]",
        "-start %d",    &startFrame,                "start frame [1]",
        "-end %d",      &endFrame,                  "end frame [24]",
        "-step %d",     &frameStep,                 "frame step [1]",

        "-set", ARG_SUBR(GetAvarArgs),
            "Set avar, e.g. -set light 0.5 height 0.2",
        "-formats", ARG_FLAG(&formats), 
            "List supported file formats",

        // Output options       
        "-size %d", &size,
            "Set output size",
        "-xysize %d %d", &xsize, &ysize,
            "Set output size",
        0);

    if (argc == 1)
    {
        arg_form_print(arg_format);
        cout << endl;
        SceneReader::PrintSupportedFormats(cout);
        Image::PrintSupportedFormats(cout);
        exit(0);
    }

    if (arg_parse_argv(argc, argv, arg_format) < 0)
        exit(1);

    if (formats)
    {
        SceneReader::PrintSupportedFormats(cout);
        Image::PrintSupportedFormats(cout);
        exit(0);
    }

    if (clr[0] < 0)
        bgColour = cWhite * grey;
    else
        bgColour = Colour(clr[0], clr[1], clr[2]);

    if (defClr[0] >= 0)
        scPrimitive::sDefaultColour = Colour(defClr[0], defClr[1], defClr[2]);

    if (xsize < 0)
        xsize = size;
    if (ysize < 0)
        ysize = size;
}

Int RenderApp::Run()
{
    if (numFiles < 1)
        return(1);
        
    slInit();

    DrawScenes();

    return(0);
}

Void RenderApp::DrawScenes()
{
    Int                     i;
    RGBAImage               image, outImage;
    FileName                sceneFile, outFile;
    ofstream                fout;
    MesaRenderer            r;

    scene = 0;  
    if (super)
        image.SetSize(2 * xsize, 2 * ysize);
    else
        image.SetSize(xsize, ysize);

    r.Init(image);
    r.SetHeadlight(!noLight);
    r.SetDoubleSided(showBF);
    if (wireFrame)
        scPrimitive::sRenderStyle = renLineLoop;
    r.SetBgColour(bgColour);

    if (animFile)
    {
        anim = new Animation;

        if (!anim->ParseAnimFile(animFile))
        {
            cerr << "Couldn't open anim file" << endl;
            exit(1);
        }
        else
            cerr << "animation of " << anim->length << " seconds read" << endl;     
        if (startFrame < 0)
        {
            startFrame = 1;
            if (endFrame < 0)
                endFrame = Int(anim->length * fps);
        }
        else if (endFrame < 0)
            endFrame = startFrame;

        frame = startFrame;
    }
        
    for (i = 0; i < numFiles; i++)
    {
        delete scene;
        sceneFile.SetPath(files[i]);

        ReadScene(sceneFile);
        if (scene)
        {
            scene->Set(new scColour(scPrimitive::sDefaultColour));
            itsCamera = (scCamera*) scene->FindFirst(aCamera);
            if (!itsCamera)
                itsCamera = new scCamera;
            scene->Set(itsCamera);

            do
            {
                if (anim)
                    SetAvarsFromAnim(scene);
                else
                    SetAvars(scene);
                
                r.Clear();
                r.Draw(*scene);
                r.Show();

                if (output)
                    outFile.SetPath(output);
                else
                {
                    outFile = sceneFile;
                    if (outFile.GetExtension() == "gz")
                        outFile.RemoveExtension();
                    outFile.SetDir(".");
                    outFile.SetExtension("tif");
                }

                if (frame >= 0)
                    outFile.SetFile(outFile.GetFile() + String().Printf("-%04d", frame));
                    
                if (super)
                {
                    cout << "*** saving super-sampled image to " << outFile.GetPath() << endl;
                    outImage.SetSize(xsize, ysize);
                    image.DownSample(outImage);
                    outImage.Save(outFile);
                }
                else
                {
                    cout << "*** saving image to " << outFile.GetPath() << endl;
                    image.Save(outFile);
                }
            }
            while (anim && frame++ <= endFrame);
        }
    }
}

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

Int main(Int argc, Char **argv)
{
    RenderApp   app;
    
    app.SetOptions(argc, argv);

    return(app.Run());
}

#else

#include <iostream.h>

int main(int argc, char **argv)
{
    cout << "slrender: No MESA installed" << endl;
    return(-1);
}


#endif

---