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/thread.H>
#include <archon/util/ref.H>
#include <archon/util/options.H>
#include <archon/util/polygon_mesher.H>

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

using namespace std;
using namespace Archon;
using namespace Archon::Math;
using namespace Archon::Utilities;
using namespace Archon::X3D::Proxy;

namespace Archon
{
  namespace SaiTestApps
  {
    namespace Spot
    {
      static bool quit = false;

      Ref<SpotLight> redSpot;
      Ref<SpotLight> greenSpot;
      Ref<SpotLight> blueSpot;

      void toggleRed(Time)
      {
        static bool on = true;
        on = !on;
        if(redSpot) redSpot->on = on;
      }

      void toggleGreen(Time)
      {
        static bool on = true;
        on = !on;
        if(greenSpot) greenSpot->on = on;
      }

      void toggleBlue(Time)
      {
        static bool on = true;
        on = !on;
        if(blueSpot) blueSpot->on = on;
      }

      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;
        }

        // Create a mesh
        double a = 10;
        vector<Vector3> outline;
        for(unsigned i=0; i<50; ++i)
        {
          double v = 2*M_PI/50*i;
          outline.push_back(Vector3(a*cos(v), 0, -a*sin(v)));
        }
        vector<Vector3> meshVertices;
        vector<int> meshPolygons;
        meshPolygon(outline, 0.25, meshVertices, meshPolygons);

        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->scale = Vector3(1, 1, 1);
        rootTransform->translation = Vector3(0, -6, 0);
        rootGroup->children.add(rootTransform);

        Ref<Coordinate> coord = Coordinate::create(application);
        coord->point = meshVertices;
        Ref<IndexedFaceSet> indexedFaceSet = IndexedFaceSet::create(application);
        indexedFaceSet->coord = coord;
        indexedFaceSet->coordIndex = meshPolygons;
        Ref<Shape> shape = Shape::create(application);
        shape->geometry = indexedFaceSet;
        Ref<Appearance> appearance = Appearance::create(application);
        appearance->material = Material::create(application);

        /*
          Ref<ImageTexture> texture = ImageTexture::create(context);
          vector<string> url;
          url.push_back("clock.png");
          texture->setUrl(url);
          apperance->setTexture(texture);
        */

        shape->appearance = appearance;

        vector<Ref<ChildNode> > children1;
        children1.push_back(shape);

        vector<double> keys;
        keys.push_back(0.0/3);
        keys.push_back(1.0/3);
        keys.push_back(2.0/3);
        keys.push_back(3.0/3);

        vector<Rotation3> keyValues;
        keyValues.push_back(Rotation3(Vector3(cos(2*M_PI*0/3), 0, -sin(2*M_PI*0/3)), 0.3));
        keyValues.push_back(Rotation3(Vector3(cos(2*M_PI*1/3), 0, -sin(2*M_PI*1/3)), 0.3));
        keyValues.push_back(Rotation3(Vector3(cos(2*M_PI*2/3), 0, -sin(2*M_PI*2/3)), 0.3));
        keyValues.push_back(Rotation3(Vector3(cos(2*M_PI*3/3), 0, -sin(2*M_PI*3/3)), 0.3));

        {
          Ref<SpotLight> spot = SpotLight::create(application);
          redSpot = spot;
          spot->color = Vector3(1, 0, 0);
          spot->beamWidth = M_PI*1/8;
          spot->cutOffAngle = M_PI*3/8;
          spot->direction = Vector3(0, -1, 0);
          Ref<Transform> transform = Transform::create(application);
          transform->translation = Vector3(2*cos(2*M_PI*0/3), 10, -2*sin(2*M_PI*0/3));
          Ref<OrientationInterpolator> orient = OrientationInterpolator::create(application);
          orient->key = keys;
          orient->keyValue = keyValues;
          application->createRoute(orient->value_changed, transform->rotation);
          Ref<TimeSensor> time = TimeSensor::create(application);
          time->cycleInterval = Time(2.1);
          application->createRoute(time->fraction_changed, orient->set_fraction);
          time->loop = true;
   
    
          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->radius = 0.2;
          cyl->height = 0.5;
          Ref<Material> mat = Material::create(application);
          mat->diffuseColor = Vector3(1, 0.5, 0.5);
          Ref<Appearance> appearance = Appearance::create(application);
          appearance->material = mat;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          shape->appearance = appearance;
    
          Ref<TouchSensor> touch = TouchSensor::create(application);
          touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(toggleRed));

          vector<Ref<ChildNode> > children;
          children.push_back(spot);
          children.push_back(orient);
          children.push_back(time);
          children.push_back(shape);
          children.push_back(touch);
          transform->children = children;
          children1.push_back(transform);
        }

        {
          Ref<SpotLight> spot = SpotLight::create(application);
          greenSpot = spot;
          spot->color = Vector3(0, 1, 0);
          spot->beamWidth = M_PI*1/8;
          spot->cutOffAngle = M_PI*3/8;
          spot->direction = Vector3(0, -1, 0);
          Ref<Transform> transform = Transform::create(application);
          transform->translation = Vector3(2*cos(2*M_PI*1/3), 10, -2*sin(2*M_PI*1/3));
          Ref<OrientationInterpolator> orient = OrientationInterpolator::create(application);
          orient->key = keys;
          orient->keyValue = keyValues;
          application->createRoute(orient->value_changed, transform->rotation);
          Ref<TimeSensor> time = TimeSensor::create(application);
          time->cycleInterval = Time(2.4);
          application->createRoute(time->fraction_changed, orient->set_fraction);
          time->loop = true;

          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->radius = 0.2;
          cyl->height = 0.5;
          Ref<Material> mat = Material::create(application);
          mat->diffuseColor = Vector3(0.5, 1, 0.5);
          Ref<Appearance> appearance = Appearance::create(application);
          appearance->material = mat;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          shape->appearance = appearance;

          Ref<TouchSensor> touch = TouchSensor::create(application);
          touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(toggleGreen));
    
          vector<Ref<ChildNode> > children;
          children.push_back(spot);
          children.push_back(orient);
          children.push_back(time);
          children.push_back(shape);
          children.push_back(touch);
          transform->children = children;
          children1.push_back(transform);
        }

        {
          Ref<SpotLight> spot = SpotLight::create(application);
          blueSpot = spot;
          spot->color = Vector3(0, 0, 1);
          spot->beamWidth = M_PI*1/8;
          spot->cutOffAngle = M_PI*3/8;
          spot->direction = Vector3(0, -1, 0);
          Ref<Transform> transform = Transform::create(application);
          transform->translation = Vector3(2*cos(2*M_PI*2/3), 10, -2*sin(2*M_PI*2/3));
          Ref<OrientationInterpolator> orient = OrientationInterpolator::create(application);
          orient->key = keys;
          orient->keyValue = keyValues;
          application->createRoute(orient->value_changed, transform->rotation);
          Ref<TimeSensor> time = TimeSensor::create(application);
          time->cycleInterval = Time(2.7);
          application->createRoute(time->fraction_changed, orient->set_fraction);
          time->loop = true;

          Ref<Cylinder> cyl = Cylinder::create(application);
          cyl->radius = 0.2;
          cyl->height = 0.5;
          Ref<Material> mat = Material::create(application);
          mat->diffuseColor = Vector3(0.5, 0.5, 1);
          Ref<Appearance> appearance = Appearance::create(application);
          appearance->material = mat;
          Ref<Shape> shape = Shape::create(application);
          shape->geometry = cyl;
          shape->appearance = appearance;

          Ref<TouchSensor> touch = TouchSensor::create(application);
          touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(toggleBlue));

          vector<Ref<ChildNode> > children;
          children.push_back(spot);
          children.push_back(orient);
          children.push_back(time);
          children.push_back(shape);
          children.push_back(touch);
          transform->children = children;
          children1.push_back(transform);
        }

        rootTransform->children = children1;
        session->endUpdate();

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

        Archon::Utilities::Time delay(0, 100000000l);
        while(!quit)
        {
          session->beginUpdate();
          session->endUpdate();

          Archon::Utilities::Thread::sleep(delay);
        }

        return 0;
      }
    }
  }
}

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

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

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

---