main.C

Go to the documentation of this file.

/*
 * 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 <iostream>

#include <archon/math/vector.H>
#include <archon/util/time.H>
#include <archon/util/mutex.H>
#include <archon/util/ref.H>
#include <archon/util/options.H>

#include <archon/x3d/proxy/exception.H>
#include <archon/x3d/proxy/proxy.H>

namespace Archon
{
  namespace SaiTestApps
  {
    namespace Clock
    {
      using namespace std;
      using namespace Math;
      using namespace Utilities;
      using namespace X3D::Proxy;

      static bool quit = false;
      static Ref<Material> quitMaterial;

      static bool fastForward = false;
      static Ref<Material> fastForwardMaterial;

      void quitIsOver(const bool v)
      {
        quitMaterial->diffuseColor = (v ? Vector3(1, 0, 0) : Vector3(0.8, 0.3, 0.3));
      }

      void quitTouch(const Time)
      {
        quit = true;
      }

      void fastForwardIsOver(const bool v)
      {
        fastForwardMaterial->diffuseColor = (v ? Vector3(0, 1, 0) : Vector3(0.3, 0.8, 0.3));
      }

      void fastForwardTouch(const Time)
      {
        fastForward = !fastForward;
      }

      int main(int argc, const char *argv[])
      {
        bool   opt_help              = false;
        int    opt_corbaEndpointPort = -1; // Auto assign
        string opt_serverName        = "archon";

        Options o;

        o.addSwitch("h", "help", opt_help, true,
                 "Describe the parameters");
        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("n", "server-name", opt_serverName, opt_serverName,
                 "The name of the server to connect to",
                 Options::wantArg_always);

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

        if(opt_help)
        {
          cout <<
            "Test Application for 3D-Console by Brian Kristiansen & Kristian Spangsege\n"
            "\n"
            "Synopsis: " << argv[0] << "\n"
            "\n"
            "Available options:\n";
          cout << o.list();
          return 0;
        }

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

        Ref<Session> session =
          Session::create(opt_serverName, opt_corbaEndpointPort);

        Ref<Application> application =
          Application::create(session, Uri());

        session->beginUpdate();

        Ref<Group> rootGroup = Group::create(application);

        Ref<Transform> rootTransform = Transform::create(application);
        rootTransform->rotation = Rotation3(Vector3(1, 0, 0), M_PI/2);
        rootTransform->scale = Vector3(8, 8, 8);
        rootGroup->children.add(rootTransform);

        {
          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->side = false;
          cyl->top = true;
          cyl->bottom = false;
          cyl->height = 0.1;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          Ref<Appearance> apperance = Appearance::create(application);
          apperance->material = Material::create(application);
          Ref<ImageTexture> texture = ImageTexture::create(application);
          texture->url.add("clock.png");
          apperance->texture = texture;
          shape->appearance = apperance;
          rootTransform->children.add(shape);
        }

        {
          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->side = true;
          cyl->top = false;
          cyl->bottom = true;
          cyl->height = 0.1;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          Ref<Appearance> apperance = Appearance::create(application);
          apperance->material = Material::create(application);
          shape->appearance = apperance;
          rootTransform->children.add(shape);
        }

        // Quit
        {
          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->side = true;
          cyl->top = true;
          cyl->bottom = false;
          cyl->height = 0.1;
          cyl->radius = 0.04;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          Ref<Appearance> apperance = Appearance::create(application);
          quitMaterial = Material::create(application);
          quitMaterial->diffuseColor = Vector3(0.8, 0.3, 0.3);
          apperance->material = quitMaterial;
          shape->appearance = apperance;
          Ref<TouchSensor> touch = TouchSensor::create(application);
          touch->isOver.registerInterest<SFBool>(new FuncCaller<SFBool>(quitIsOver));
          touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(quitTouch));
          Ref<Transform> transform = Transform::create(application);
          transform->children.add(shape);
          transform->children.add(touch);
          transform->translation = Vector3(0, 0, -1.03);
          transform->rotation = Rotation3(Vector3(-1, 0, 0), M_PI/2);
          rootTransform->children.add(transform);
        }

        // Fast forward
        {
          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->side = true;
          cyl->top = true;
          cyl->bottom = false;
          cyl->height = 0.1;
          cyl->radius = 0.04;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          Ref<Appearance> apperance = Appearance::create(application);
          fastForwardMaterial = Material::create(application);
          fastForwardMaterial->diffuseColor = Vector3(0.3, 0.8, 0.3);
          apperance->material = fastForwardMaterial;
          shape->appearance = apperance;
          Ref<TouchSensor> touch = TouchSensor::create(application);
          touch->isOver.registerInterest<SFBool>(new FuncCaller<SFBool>(fastForwardIsOver));
          touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(fastForwardTouch));
          Ref<Transform> subTransform = Transform::create(application);
          subTransform->children.add(shape);
          subTransform->children.add(touch);
          subTransform->translation = Vector3(0, 0, -1.03);
          subTransform->rotation = Rotation3(Vector3(-1, 0, 0), M_PI/2);
          Ref<Transform> transform = Transform::create(application);
          transform->children.add(subTransform);
          transform->rotation = Rotation3(Vector3(0, -1, 0), M_PI/16);
          rootTransform->children.add(transform);
        }

        Ref<ChildNode> pointer;
        {
          Ref<Box> box = Box::create(application);
          box->size = Vector3(0.05, 0.02, 0.9);
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = box;
          Ref<Appearance> apperance = Appearance::create(application);
          Ref<Material> material = Material::create(application);
          material->diffuseColor = Vector3(0.5, 0.2, 0.2);
          apperance->material = material;
          shape->appearance = apperance;
          Ref<Transform> transform = Transform::create(application);
          transform->children.add(shape);
          transform->translation = Vector3(0, 0, -0.4);
          pointer = transform;
        }

        Ref<Transform> seconds = Transform::create(application);
        seconds->children.add(pointer);
        seconds->translation = Vector3(0, 0.1, 0);
        seconds->scale = Vector3(0.3, 1, 1);
        rootTransform->children.add(seconds);

        Ref<Transform> minutes = Transform::create(application);
        minutes->children.add(pointer);
        minutes->translation = Vector3(0, 0.08, 0);
        rootTransform->children.add(minutes);

        Ref<Transform> hours = Transform::create(application);
        hours->children.add(pointer);
        hours->translation = Vector3(0, 0.06, 0);
        hours->scale = Vector3(1, 1, 0.6);
        rootTransform->children.add(hours);

        session->endUpdate();

        application->setRootGroup(rootGroup);
        application->launch();

        long addition = 0;

        Archon::Utilities::Time delay(0, 100000000l);
        while(!quit)
        {
          long sec, nsec;
          Time t = Time::now();
          if(fastForward) addition += 60000;
          t.addMilliSeconds(addition);
          t.get(sec, nsec);
          time_t t1 = sec;
          tm t2;
          localtime_r(&t1, &t2);

          double n = nsec/1E9;
          double s = (t2.tm_sec + n)/60;
          double m = (t2.tm_min + s)/60;
          double h = (t2.tm_hour + m)/12;

          session->beginUpdate();

          seconds->rotation = Rotation3(Vector3(0, -1, 0), s*2*M_PI);
          minutes->rotation = Rotation3(Vector3(0, -1, 0), m*2*M_PI);
          hours->rotation = Rotation3(Vector3(0, -1, 0), h*2*M_PI);

          session->endUpdate();
          Archon::Utilities::Thread::sleep(delay);
        }

        return 0;
      }
    }
  }
}

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

  set_unexpected(Exception::terminal<Proxy::exceptionCatchInfo>);
  set_terminate (Exception::terminal<Proxy::exceptionCatchInfo>);

  return Archon::SaiTestApps::Clock::main(argc, argv);
}

---