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 <string>
#include <iostream>

#include <archon/util/term.H>
#include <archon/util/text.H>
#include <archon/util/options.H>
#include <archon/util/logger.H>
#include <archon/util/uri.H>
#include <archon/util/web_client.H>
#include <archon/util/file.H>

#include <archon/x3d/server/x3d.H>
#include <archon/x3d/server/server.H>
#include <archon/x3d/server/parse_xml.H>
//#include <archon/x3d/server/font.H>
#include <archon/x3d/server/text.H>

#include <archon/x3d/sai/listener.H>

#include <archon/3dconsole/exception.H>
#include <archon/3dconsole/options.H>
#include <archon/3dconsole/scene_view.H>

using namespace std;

namespace Archon
{
  using namespace Utilities;

  namespace Console3d
  {
    struct LoaderJob: X3D::Loader::Job
    {
      LoaderJob(Ref<X3D::Loader> l, const vector<string> &uriList):
        X3D::Loader::Job(l, Uri(), uriList, X3D::Loader::uriType_X3D) {}
    };

    string getPrivateDir()
    {
      return File::getHomeDir() + "/.archon";
    }

    void evokePrivateDir(string path)
    {
      string d = getPrivateDir();
      if(!Text::isPrefixOf(d, path)) return;
      if(!File::isDir(d)) File::makeDir(d);
    }

    int main(int argc, const char *argv[])
    {
      Options o;

      o.addSwitch("h", "help", opt_help, true,
                  "Describe the parameters");
      o.addSwitch("c", "config-file", opt_configFile, opt_configFile,
                  "Set the path of the configuration file",
                  Options::wantArg_always);
      o.addSwitch("",  "save-config", opt_saveConfig, true,
                  "Save the modified configuration into the configuration file");
      o.addSwitch("",  "dump-node-defs", opt_dumpNodeDefs, true,
                  "Dump the definition of all known X3D nodes and exit");
      o.addConfig("F", "full-screen", opt_fullScreen, true,
                  "View in fullscreen mode",
                  Options::wantArg_optional);
      o.addConfig("r", "resolution", opt_resolution, opt_resolution,
                  "Set resolution",
                  Options::wantArg_always);
      o.addConfig("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.addConfig("e", "eyepoint", opt_eyepoint, opt_eyepoint,
                  "Location of the eye in the default view",
                  Options::wantArg_always);
      o.addConfig("l", "lookat", opt_lookat, opt_lookat,
                  "Point of interest in the default view",
                  Options::wantArg_always);
      o.addConfig("v", "field-of-view", opt_fieldOfView, opt_fieldOfView,
                  "Smallest edge-to-edge angle of viewplane when seen from "
                  "the eye",
                  Options::wantArg_always);
      o.addConfig("H", "head-light", opt_headLight, true,
                  "Enable head light",
                  Options::wantArg_optional);
      o.addConfig("L", "show-light-sources", opt_showLightSources, true,
                  "Display light sources as points in their color",
                  Options::wantArg_optional);
      o.addConfig("w", "wireframe", opt_wireframe, true,
                  "Render the scene in wireframe instead of the usual filled "
                  "polygons",
                  Options::wantArg_optional);
      o.addConfig("t", "texture", opt_texture, true,
                  "Enable use of texture mapping",
                  Options::wantArg_optional);
      o.addConfig("m", "mipmap", opt_mipmap, true,
                  "Enable mipmaped textures. You need this for textures whos "
                  "dimentions are not a power of 2. Note also that there are "
                  "some probplems when using mipmaps together with projective "
                  "textures.",
                  Options::wantArg_optional);
      o.addConfig("N", "show-normals", opt_showNormals, true,
                  "Reveal the normal at each rendered vertex",
                  Options::wantArg_optional);
      o.addConfig("", "text-as-quads-mode", opt_textAsQuadsMode, true,
                  "Display the quad for each character instead of the character itself.",
                  Options::wantArg_optional);
      o.addConfig("f", "frame-rate", opt_frameRate, opt_frameRate,
                  "Set the number of frames per second",
                  Options::wantArg_always);
      o.addConfig("s", "subdivision", opt_subdivision, opt_subdivision,
                  "Set subdivision of curved geometry such as sphers, tori, "
                  "cylinders and cones",
                  Options::wantArg_always);
      o.addConfig("b", "application-heartbeat", opt_applicationHeartbeat, opt_applicationHeartbeat,
                  "Set the delay in seconds between pings from the server to "
                  "the applications",
                  Options::wantArg_always);
      o.addConfig("p", "corba-endpoint-port", opt_corbaEndpointPort, opt_corbaEndpointPort,
                  "The TCP/IP port on which the CORBA Orb listens (-1 for auto "
                  "assign)",
                  Options::wantArg_always);
      o.addConfig("a", "accept-clients", opt_acceptClients, true,
                  "Accept connection from client applications via the SAI",
                  Options::wantArg_optional);
      o.addConfig("n", "console-name", opt_consoleName, opt_consoleName,
                  "Set the name of this server as known by SAI clients",
                  Options::wantArg_always);
      o.addConfig("D", "dump-scene", opt_dumpScene, true,
                  "Write out a textual description of the scene at the time of "
                  "exit",
                  Options::wantArg_optional);
      o.addConfig("P", "progressive-load", opt_progressiveLoad, true,
                  "View scene while loading",
                  Options::wantArg_optional);
      o.addConfig("", "font-path", opt_fontPath, opt_fontPath,
                  "A colon seperated list of directories in which to look "
                  "for fonts. Empty entries are ignored.",
                  Options::wantArg_always);

      bool optionError = false;
      if(o.processCommandLine(argc, argv, true))
        optionError = true;

      bool configFileSpecified = !opt_configFile.empty();
      if(opt_configFile.empty())
        opt_configFile = getPrivateDir() + "/archon.conf";
      try
      {
        if(o.processConfigFile(opt_configFile))
          optionError = true;
      }
      catch(Options::FileAccessException &e)
      {
        if(configFileSpecified)
          cerr << "WARNING: " + e.getMessage() + "\n";
      }

      if(o.processCommandLine(argc, argv, false))
        optionError = true;

      if(opt_help)
      {
        cout <<
          "3D-Console by Brian Kristiansen & Kristian Spangsege\n"
          "\n"
          "Synopsis: " + string(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" +
          o.list();
        return optionError ? 1 : 0;
      }

      if(optionError)
      {
        cerr << "Try --help\n";
        return 1;
      }

      if(opt_saveConfig) try
      {
        evokePrivateDir(opt_configFile);
        o.saveConfigFile(opt_configFile);
      }
      catch(Options::FileAccessException &e)
      {
        cerr << "WARNING: " + e.getMessage() + "\n";
      }

      // Treat 1st arg if present as URL of X3D file to load
      if(argc > 2)
      {
        cerr << "Too many aguments\n";
        cerr << "Try --help\n";
        return 1;
      }

      bool uriSpecified = false;
      UriReference x3dUriReference;
      string uriException;
      if(argc>1) try
      {
        x3dUriReference = UriReference(argv[1]);
        uriSpecified = true;
      }
      catch(Uri::SyntaxException &e)
      {
        uriException = Uri::explain(e);
      }

      if(!uriException.empty())
      {
        cerr << uriException;
        exit(1);
      }

      Logger *logger = Logger::get();

      {
        vector<string> fontDirs;
        {
          string::size_type i = 0;
          for(;;)
          {
            string::size_type j = opt_fontPath.find(':', i);
            if(j == string::npos) j = opt_fontPath.size();
            if(j != i) fontDirs.push_back(opt_fontPath.substr(i, j-i));
            if(j == opt_fontPath.size()) break;
            i = j+1;
          }
        }

        for(unsigned i=0; i<fontDirs.size(); ++i)
          X3D::addFontPath(fontDirs[i]);

        X3D::initialize();

        if(opt_dumpNodeDefs)
        {
          X3D::NodeType::describeAll(logger);
          exit(0);
        }

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

        // Activate the SAI connection listener
        if(opt_acceptClients)
        {
          Time applicationHeartbeat(opt_applicationHeartbeat);
          Ref<X3D::SAI::Listener> listener =
            new X3D::SAI::Listener(server, applicationHeartbeat,
                                   opt_corbaEndpointPort);

          try
          {
            listener->startServingClientRequests(server->getRootScene()->getRootGroup());
            server->setListener(listener);
          }
          catch(X3D::SAI::Listener::NameServerException &e)
          {
            logger->log("WARNING: " + e.getMessage() + " (Client access disabled)");
          }
        }

        // Set up the default viewpoint
        CoordSystem3x3 viewCoordSystem(opt_eyepoint, Matrix3x3(Vector3(0, 1, 0), opt_eyepoint - opt_lookat));

        string viewpointName = x3dUriReference.getFragmentIdentifier();
        if(!viewpointName.empty()) viewpointName.erase(0, 1);

        viewScene(server,
                  viewpointName,
                  viewCoordSystem,
                  opt_fieldOfView,
                  dist(opt_eyepoint, opt_lookat),
                  opt_backgroundColor,
                  opt_resolution.x, opt_resolution.y,
                  opt_fullScreen, opt_showLightSources, opt_headLight,
                  opt_wireframe, opt_texture, opt_mipmap, opt_showNormals, opt_textAsQuadsMode,
                  opt_subdivision.x, opt_subdivision.y,
                  opt_frameRate);

        //if(opt_dumpScene) cout << server->dumpScenegraph();
      }

      logger->log("Waiting for all threads to terminate");
      Thread::mainExitWait();

      return 0;
    }
  }
}

int main(int argc, const char *argv[]) throw()
{
  using namespace Archon::Utilities;

  set_unexpected(Exception::terminal<Archon::Console3d::exceptionCatchInfo>);
  set_terminate (Exception::terminal<Archon::Console3d::exceptionCatchInfo>);

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

---