---

Writers.cc

Go to the documentation of this file.

/*
    File:       Writers.cc

    Function:   Implements various scene writer functions

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/Writers.h"
#include "gcl/SceneObjects.h"

#define INFO_COUT cerr

Int ObjWriter::pointsWritten;
FILE *ObjWriter::file = 0;

Void ObjWriter::HandlePoly(
        Int         numVertices,
        Int         vertices[],
        Int         changed
    )
{
    Int         i;

    if (numVertices < 0) return;
            
    if (pointsWritten < pointsAcc->NumItems())
    {
        for (i = pointsWritten; i < pointsAcc->NumItems(); i++)
            fprintf(file, "v %g %g %g\n", (*pointsAcc)[i][0],
                (*pointsAcc)[i][1],
                (*pointsAcc)[i][2]
            );
        pointsWritten = pointsAcc->NumItems();
    }

    fprintf(file, "f");
    for (i = 0; i < numVertices; i++)
        fprintf(file, " %d", vertices[i] + 1);
    fprintf(file, "\n");
}

Void ObjWriter::SaveAs(scScenePtr scene, StrConst filename)
{
    file = fopen(filename, "w");

    if (!file)
    {
        _Warning("(WriteObjFile) couldn't open output file for writing");
        return;
    }

    fprintf(file, "# GCL scene wavefront writer\n");

    fprintf(file, "\n");

    // dump points, colours, and texture coords if we have 'em.

    pointsWritten = 0;
    scene->Decimate(SELF, DecUseMaster);

    fclose(file);
}

// --- MGF format ----------------------------------------------------------------

Int MGFWriter::vertNum;
Int MGFWriter::pointsWritten;
FILE *MGFWriter::file = 0;

Void MGFWriter::HandlePoly(
        Int         numVertices,
        Int         vertices[],
        Int         changed
    )
{
    Int         i;

    const Colour wtMGF(0.265, 0.670, 0.065);

    if (numVertices < 0) return;
            
    if (changed)
    // write out new material definition
    {
        Colour      *reflectancePtr = SC_GET(Colour), rdc;
        Colour      *emittancePtr = SC_GET(Emittance), edc;
        ClrReal     rd, ed;
        
        if (reflectancePtr)
            rdc = *reflectancePtr;  
        else
            rdc = scPrimitive::sDefaultColour;

        rd = dot(wtMGF, rdc);
        if (rd > 0.0)
            rdc /= rd;
        rdc *= wtMGF;
        
        if (emittancePtr)
        {
            edc = *emittancePtr;
            // MGF 'ed' is illuminance, i.e., photometric irradiance.
            // we are (currently) pure irradiance
            edc *= 179.0;
            ed = dot(wtMGF, edc);
            if (ed > 0.0)
                edc /= ed;
            edc *= wtMGF;
        }
        else
            ed = 0.0;

        fprintf(file, "m\n");
        // MGF parser has problems with cmix 0 R 0 G 0 B...
        if (rd > 0.0)
            fprintf(file,
                "\tc\n\t\tcmix %g R %g G %g B\n"
                "\trd %g\n",
                rdc[0], rdc[1], rdc[2],
                rd
            );
        else
            fprintf(file, 
                "\trd 0.0\n"
            );
        
        if (ed > 0.0)
            fprintf(file, 
                "\tc\n\t\tcmix %g R %g G %g B\n"
                "\ted %g\n",
                edc[0], edc[1], edc[2],
                ed
            );
        else
            fprintf(file, 
                "\ted 0.0\n"
            );      
    }
    
    if (pointsWritten < pointsAcc->NumItems())
    {
        for (i = pointsWritten; i < pointsAcc->NumItems(); i++)
            fprintf(file, "v v%d = \n\tp %g %g %g\n",
                vertNum++,
                (*pointsAcc)[i][0],
                (*pointsAcc)[i][1],
                (*pointsAcc)[i][2]
            );
        pointsWritten = pointsAcc->NumItems();
    }

    fprintf(file, "f");
    for (i = 0; i < numVertices; i++)
        fprintf(file, " v%d", vertices[i]);
    fprintf(file, "\n");
}

Void MGFWriter::SaveAs(scScenePtr scene, StrConst filename)
{
    file = fopen(filename, "w");

    if (!file)
    {
        _Warning("(WriteMGFFile) couldn't open output file for writing");
        return;
    }

    fprintf(file, "# GCL scene MGF format writer\n");

    fprintf(file, "\n");
    fprintf(file, "o test\n");
    // MGF files are generally zup, so 'correct' our usual yup
    fprintf(file, "xf -rx 90\n");
    fprintf(file, 
        "c R =\n"
        "   cxy 0.64 0.33\n"
        "c G =\n"
        "   cxy 0.29 0.6\n"
        "c B =\n"
        "   cxy 0.15 0.06\n\n");

    // dump points and colours
    // only attempt to write out polygon meshes at the moment, though
    // MGF can handle more.
    // need to add normals etc.

    pointsWritten = 0;
    vertNum = 0;
    
    scene->Decimate(SELF, DecUseMaster);

    fclose(file);
}

// --- Rad format ----------------------------------------------------------------

// this is here 'cause mgf2rad dumps core on large (polygonal) scenes
// quick & dirty
// note: that bug's since been fixed by Greg; it was a problem with the hash
// table code.

Int RadWriter::matNum;
Int RadWriter::polyNum;
Int RadWriter::pointsWritten;
FILE *RadWriter::file = 0;

Void RadWriter::HandlePoly(
        Int         numVertices,
        Int         vertices[],
        Int         changed
    )
{
    PointList   *points = SC_GET(Points);   
    Int         i;

    if (numVertices < 0 || points == 0) return;
            
    if (changed)
    {
        Colour      *reflectancePtr = SC_GET(Colour), rdc;
        Colour      *emittancePtr = SC_GET(Emittance), edc;
        
        matNum++;

        if (reflectancePtr)
            rdc = *reflectancePtr;  
        else
            rdc = cOrange;
        
        if (emittancePtr)
        {
            edc = *emittancePtr;
            // convert from irradiance to radiance necessary for the
            // .rad format.
            edc /= vl_pi;
        }
        else
            edc = cBlack;

        if (len(edc) > 0.0)
        {
            fprintf(file, "void light mat%d\n", matNum);
            fprintf(file, "0\n0\n3 %g %g %g\n\n", 
                edc[0], edc[1], edc[2]);
        }
        else
        {
            fprintf(file, "void plastic mat%d\n", matNum);
            fprintf(file, "0\n0\n5 %g %g %g 0.0 0.0\n\n", 
                rdc[0], rdc[1], rdc[2]);
        }
    }
    
    fprintf(file, "mat%d polygon f%d\n0\n0\n%d\n",
        matNum, polyNum++, numVertices * 3
    );

    for (i = 0; i < numVertices; i++)
    {
        Point p = (*points)[vertices[i]];

        p = xform(transAcc, p);
        
        fprintf(file, "%-20g %-20g %-20g\n",
            p[0], p[1], p[2]
        );
    }

    fprintf(file, "\n");
}

Void RadWriter::SaveAs(scScenePtr scene, StrConst filename)
{
    file = fopen(filename, "w");

    if (!file)
    {
        _Warning("(WriteRadFile) couldn't open output file for writing");
        return;
    }

    fprintf(file, "# GCL scene Radiance format writer\n");

    fprintf(file, "\n");

    pointsWritten = 0;
    matNum = 0;
    polyNum = 1;
    
    scene->Decimate(SELF, 0);

    fclose(file);
}

// --- Generic writer -------------------------------------------------------------

Void SceneWriter::Save(scScenePtr scene, FileName filename)
{
    INFO_COUT << "Writing " << filename.GetPath() << endl;

    if (filename.GetExtension() == "mgf")
        MGFWriter().SaveAs(scene, filename.GetPath());
    else if (filename.GetExtension() == "obj")
        ObjWriter().SaveAs(scene, filename.GetPath());
    else if (filename.GetExtension() == "rad")
        RadWriter().SaveAs(scene, filename.GetPath());
    else if (filename.GetExtension() == "sl")
    {
        ofstream fout;

        fout.open(filename.GetPath());
        if (fout)
        {
            scene->Print(fout);
            fout.close();
        }
        else
            perror("Couldn't open output file");
    }
    else
    {
        INFO_COUT << "unknown scene file extension " << filename.GetExtension()
            << ": saving as default (obj)" << endl;
        filename.SetExtension("obj");
        ObjWriter().SaveAs(scene, filename.GetPath());
    }
}

static StrConst tSceneWriterFormats[] = 
{
    "sl",           "GCL's scene language.",
    "obj",          "Wavefront .obj ascii format [default]",
    "mgf",          "material and geometry format",
    "rad",          "radiance format",
    "mrb",          "binary multi-resolution model(s)",
    0
};

Void SceneWriter::PrintSupportedFormats(ostream &s)
{
    StrConst    *str = tSceneWriterFormats;
    Int         i;
    
    while (*str)
    {
        s << "  " << *str;
        for (i = 0; i < 4 - str->Length(); i++)
            s << ' ';
        str++;
        s << *str++ << endl;
    }
}

---