main.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <unistd.h>


#include <string>
#include <typeinfo>
#include <iostream>
#include <vector>
#include <map>

#include <archon/util/term.H>
#include <archon/util/text.H>
#include <archon/util/options.H>
#include <archon/util/uri.H>
#include <archon/util/thread.H>
#include <archon/util/logger.H>
#include <archon/util/parse_values.H>
#include <archon/util/text.H>
#include <archon/x3d/exception.H>
#include <archon/x3d/x3d.H>
#include <archon/x3d/load.H>

#include "exception.H"
#include "options.H"
#include "object.H"
#include "world.H"
#include "engine.H"
#include "sceneloader.H"
#include "scene_view.H"

using namespace std;

namespace Archon
{
  using namespace Utilities;

  namespace Raytracer
  {
    struct Logger: public Utilities::Logger
    {
      Semaphore s;

      virtual ~Logger() {}

      void log(string message)
      {
        Logger::get()->log(message);
      }
    }
    logger;

    /*
    struct Producer: public Thread
    {
      Stream::Writer w;
      const char *s;

      Producer(Stream::Writer w, const char *s):w(w), s(s) {}
      ~Producer() { wait(); }

      virtual void main()
      {
        char buffer[64];

        for(int i=0;i<2;++i)
        {
          sprintf(buffer, "%s(%d)\n", s, i);
          w.writeAll(buffer, strlen(buffer));
        }
        w.close();
      }
    };

    struct Consumer: public Thread
    {
      Stream::Reader r;

      Consumer(Stream::Reader r):r(r) {}
      ~Consumer() { wait(); }

      virtual void main()
      {
        for(;;)
        {
          char b[1025];
          int n = r.read(b, 1025);
          if(n == 0) break;
          cerr << string(b, n);
        }
        r.close();
      }
    };
    */

    int main(int argc, const char *argv[])
    {
      /*
      //
      // Example 4.34 from the Dragon Book
      //
      {
      CFG g;
      const int plus = g.defineTerminal("+");
      const int star = g.defineTerminal("*");
      const int lpar = g.defineTerminal("(");
      const int rpar = g.defineTerminal(")");
      const int id   = g.defineTerminal("id");

      const int e  = g.defineNonterminal("E");
      const int t  = g.defineNonterminal("T");
      const int f  = g.defineNonterminal("F");

      g.addProduction(e, CFG::nonterm(e), CFG::term(plus), CFG::nonterm(t));
      g.addProduction(e, CFG::nonterm(t));
      g.addProduction(t, CFG::nonterm(t), CFG::term(star), CFG::nonterm(f));
      g.addProduction(t, CFG::nonterm(f));
      g.addProduction(f, CFG::term(lpar), CFG::nonterm(e), CFG::term(rpar));
      g.addProduction(f, CFG::term(id));

      cerr << g.print(System::Term::getWidth()) << "\n";
      ClrParser parser(g);      
      }
      */

      /*
      //
      // Example 4.39 from the Dragon Book
      //
      {
      CFG g;
      const int equal = g.defineTerminal("=");
      const int star  = g.defineTerminal("*");
      const int id    = g.defineTerminal("id");

      const int S  = g.defineNonterminal("S");
      const int L  = g.defineNonterminal("L");
      const int R  = g.defineNonterminal("R");

      g.addProduction(S, CFG::nonterm(L), CFG::term(equal), CFG::nonterm(R));
      g.addProduction(S, CFG::nonterm(R));
      g.addProduction(L, CFG::term(star), CFG::nonterm(R));
      g.addProduction(L, CFG::term(id));
      g.addProduction(R, CFG::nonterm(L));

      cerr << g.print(System::Term::getWidth()) << "\n";
      ClrParser parser(g);      
      }
      */

      /*
      //
      // Example 4.42 from the Dragon Book
      //
      {
      CFG g;
      const int d = g.defineTerminal("d");
      const int c = g.defineTerminal("c");

      const int S  = g.defineNonterminal("S");
      const int C  = g.defineNonterminal("C");

      g.addProduction(S, CFG::nonterm(C), CFG::nonterm(C));
      g.addProduction(C, CFG::term(c), CFG::nonterm(C));
      g.addProduction(C, CFG::term(d));

      cerr << g.print(System::Term::getWidth()) << "\n";
      ClrParser parser(g);      
      }
      */

      /*
        Stream::Reader r;
        Stream::Writer w;
        Stream::makePipe(r, w);
        Producer producer1(w, "Alpha");
        Producer producer2(w, "Beta");
        Producer producer3(w, "Gamma");
        Consumer consumer(r);
        r.close();
        w.close();
        producer1.start();
        producer2.start();
        producer3.start();
        consumer.start();
      */

      Options o;

      o.addVar("h", "help", opt_help, true,
               "Describe the parameters of the raytracer");
      o.addVar("d", "display", opt_displayRendering, true,
               "Display image during rendering");
      o.addVar("r", "resolution", opt_resolution, opt_resolution,
               "Set resolution of rendered image",
               Options::wantArg_always);
      o.addVar("o", "output-file", opt_outputFileName, opt_outputFileName,
               "Set filename of rendered image",
               Options::wantArg_always);
      o.addVar("e", "eyepoint", opt_eyepoint, opt_eyepoint,
               "Location of the eye in the default view",
               Options::wantArg_always);
      o.addVar("l", "lookat", opt_lookat, opt_lookat,
               "Point of interest in the default view",
               Options::wantArg_always);
      o.addVar("f", "field-of-view", opt_fieldOfView, opt_fieldOfView,
               "Smallest edge-to-edge angle of viewplane when seen from the eye",
               Options::wantArg_always);
      o.addVar("b", "background-color", opt_backgroundColor, opt_backgroundColor,
               "R,G,B or R,G,B,A color of background (range 0-1)",
               Options::wantArg_always);
      o.addVar("p", "photon-map", opt_generatePhotonMap, true,
               "Generate a photon map and use it to produce caustics");
      o.addVar("a", "photon-map-alone", opt_showOnlyPhotonMap, true,
               "Only visualize the photon-map during raytracing");
      o.addVar("c", "caustic-photons", opt_causticPhotons, opt_causticPhotons,
               "Total number of caustic photons to emit (each light source gets a share)",
               Options::wantArg_always);
      o.addVar("P", "photons_in_estimate", opt_photonsInEstimate, opt_photonsInEstimate,
               "Number of photons in radiance estimate",
               Options::wantArg_always);
      o.addVar("v", "preview", opt_preview, true,
               "Preview the scene to adjust viewpoint");
      o.addVar("V", "preview-only", opt_previewOnly, true,
               "Only view the scene in the previewer - don't raytrace (implies -v)");
      o.addVar("F", "full-screen", opt_fullScreen, true,
               "Preview in fullscreen mode");
      o.addVar("R", "preview-resolution", opt_previewResolution, opt_previewResolution,
               "Set resolution of preview window",
               Options::wantArg_always);
      o.addVar("L", "show-light-sources", opt_showLightSources, true,
               "Display light sources in the previewer as points in their color");
      o.addVar("H", "head-light", opt_headLight, true,
               "Enable head light for scenes with no defined light sources",
               Options::wantArg_optional);
      o.addVar("t", "max-loader-threads", opt_maxLoaderThreads, opt_maxLoaderThreads,
               "Maximum number of threads to spawn for loading scene components",
               Options::wantArg_always);
      o.addVar("i", "max-loader-thread-idle", opt_maxLoaderThreadIdle, opt_maxLoaderThreadIdle,
               "Maximum idle time in seconds for loader threads before disposal",
               Options::wantArg_always);
      o.addVar(0, "frame-rate", opt_frameRate, opt_frameRate,
               "Set the number of frames per second when previewing",
               Options::wantArg_always);
      o.addVar("s", "subdivision", opt_subdivision, opt_subdivision,
               "Set subdivision of curved geometry when previewing (affects sphers, tori, cylinders and cones)",
               Options::wantArg_always);

      if(o.execute(argc, argv))
      {
        cerr << "Try --help\n";
        return 1;
      }

      UriReference x3dUriReference;
      bool malformedUri = false;
      Uri::SyntaxException uriException;
      if(argc>1) try
      {
        x3dUriReference = UriReference(argv[1]);

        /*
         * Build output file name now so that it can by displayed in the
         * option table
         */
        if(opt_outputFileName == "")
        {
          // Use the name in the input url as a basis for the output file name
          opt_outputFileName = Uri::decode(x3dUriReference.getUri().getFile(), false);

          // Chop off suffix if it is 'x3d'
          if(opt_outputFileName.size() >= 4 &&
             Text::compareIgnoreCase(opt_outputFileName.substr(opt_outputFileName.size()-4), ".x3d")==0)
            opt_outputFileName = opt_outputFileName.substr(0, opt_outputFileName.size()-4);

          opt_outputFileName += ".png";
        }
      }
      catch(Uri::SyntaxException e)
      {
        uriException = e;
        malformedUri = true;
      }

      if(opt_help)
      {
        cout <<
          "Raytracer by Brian Kristiansen & Kristian Spangsege\n"
          "\n"
          "Synopsis: " << argv[0] << " URI\n"
          "\n"
          "The URI must refer to an X3D file and\n"
          "may be specified relative to the current working directory.\n"
          "If you specify a fragment identifier it will be interpreted\n"
          "as the name of the viewpoint to use. For example\n"
          "  " << argv[0] << " house.x3d#front\n"
          "will render the house from the viewpoint named 'front'.\n"
          "\n"
          "Available options:\n";
        cout << o.list();
        return 0;
      }

      // Treat 1st arg as URL of X3D file to load
      if(argc < 2)
      {
        logger.log("Too few arguments");
        cerr << "Try --help\n";
        return 1;
      }

      if(argc > 2)
      {
        logger.log("Too many aguments");
        cerr << "Try --help\n";
        return 1;
      }

      if(malformedUri)
      {
        cerr << Uri::explain(uriException);
        exit(1);
      }

      X3D::initialize();

      Ref<X3D::Server> server = X3D::Server::get(opt_consoleName, opt_frameRate, logger,
                                                 uriSpecified, x3dUriReference.getUri(), opt_progressiveLoad);

      Ref<X3D::Scene> scene = server.getRootScene();
      Ref<X3D::Material> defaultMaterial = X3D::Material::type->instantiate(scene);

      // Set up the default viewpoint
      CoordSystem3 eye = CoordSystem3::identity;
      eye.origin += opt_eyepoint;
      eye.lookAt(opt_lookat);
      View view(eye, opt_fieldOfView, "default", "default");

      if(opt_preview || opt_previewOnly)
      {
        viewScene(scene.get(), x3dUriReference.getFragmentIdentifier(),
                  &view, opt_backgroundColor,
                  opt_previewResolution.x, opt_previewResolution.y,
                  opt_fullScreen, opt_showLightSources, opt_headLight,
                  opt_subdivision.x, opt_subdivision.y, opt_frameRate,
                  &logger);
      }
      else
      {
        vector<View> views;

        get_scene(scene, defaultMaterial, 0, &views, 0, &logger);

        int viewIndex = -1;

        string viewName = x3dUriReference.getFragmentIdentifier();
        if(!viewName.empty())
        {
          for(unsigned i=0; i<views.size(); ++i)
            if(views[i].name == viewName)
            {
              viewIndex = i;
              break;
            }
          if(viewIndex == -1)
          {
            cerr << "No view point defined with the name '" << viewName << "'\n";
            exit(1);
          }
        }
        else if(!views.empty()) for(;;)
        {
          vector<double> columnWidthFractions;
          columnWidthFractions.push_back(0.1);
          columnWidthFractions.push_back(0.3);
          columnWidthFractions.push_back(0.6);
          Text::Table<string> table(views.size()+1, columnWidthFractions);
          table(0, 1) = "Name";
          table(0, 2) = "Description";
          for(unsigned i=0; i<views.size(); ++i)
          {
            table(i+1, 0) = Text::toString(i+1);
            table(i+1, 1) = views[i].name;
            table(i+1, 2) = views[i].description;
          }

          cout <<
            "\nThe following views are defined:\n\n" <<
            Text::format(table, Term::getWidth(), 2, true) <<
            "\nChoose one [1]: ";
          string input;
          getline(cin, input);
          input = Text::trim(input);
          if(input.empty())
          {
            viewIndex = 0;
            break;
          }
          else try
          {
            viewIndex = ParseValues::parseInteger(false, input.c_str()) - 1;
            if(viewIndex >= 0 && viewIndex < (int)views.size()) break;
          }
          catch(ParseValues::Exception) {}
          cout << "Illegal choise!\n";
        }

        if(viewIndex != -1) view = views[viewIndex];
      }

      if(!opt_previewOnly)
      {
        World world(opt_backgroundColor, 0.01, 10, true,
                    opt_photonsInEstimate,
                    opt_showOnlyPhotonMap && opt_generatePhotonMap);

        get_scene(scene, defaultMaterial, &world, 0, 0, &logger);

        Engine(&logger).render(&world, view);
      }

      return 0;
    }

    void handle_unexpected()
    {
      try { throw; }
      catch(exception &e)
      {
        cerr << typeid(e).name() << ": " << e.what() << "\n";
        abort();
      }
      catch(Utilities::Exception &e)
      {
        cerr << typeid(e).name() << ": " << e.getMessage() << "\n";
        abort();
      }
      catch(X3D::Exception &e)
      {
        cerr << typeid(e).name() << ": " << e.getMessage() << "\n";
        abort();
      }
      catch(Raytracer::Exception &e)
      {
        cerr << typeid(e).name() << ": " << e.getMessage() << "\n";
        abort();
      }
      catch(...)
      {
        cerr << "Caught unknown exception\n";
        abort();
      }
    }
  }
}

int main(int argc, const char *argv[]) throw()
{
  set_unexpected(Archon::Raytracer::handle_unexpected);

  return Archon::Raytracer::main(argc, argv);
}

---