server.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 <archon/x3d/server/server.H>
#include <archon/x3d/server/parse_xml.H>

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

namespace Archon
{
  namespace X3D
  {
    Ref<Server> Server::get(string name, double frameRate, Logger *logger,
                            bool loadScene, Uri sceneUrl, bool progressiveLoad)
    {
      Ref<X3D::Server> server = new X3D::Server(name, frameRate, logger);
      Ref<Web::Client> webClient = Web::Client::get(name, "0");

      /*
      {
        Ref<X3D::FontServer> fontServer = new X3D::FontServer(server, fontDirs);
        server->setFontServer(fontServer);
      }
      */
      {
        Ref<X3D::Loader> loader = new X3D::Loader(server, webClient);
        server->setLoader(loader);
      }

      // Load
      Uri rootUrl;
      if(loadScene) rootUrl = sceneUrl;
      Ref<X3D::Scene> rootScene = new X3D::Scene(server, rootUrl);
      Ref<X3D::Group> rootGroup = new X3D::Group(Ref<X3D::ExecutionContext>(rootScene));

      /*
      if(progressiveLoad)
      {
        rootScene->setRootGroup(rootGroup);
        server->setRootScene(rootScene);
        load(rootGroup);
      }
      */

      if(loadScene)
      {
        Ref<Web::Client::Response> response =
          webClient->request(Web::Client::Request::get(rootUrl));
        X3D::XML::parse(rootScene, rootGroup, response, progressiveLoad);
      }
      rootScene->setRootGroup(rootGroup);
      server->setRootScene(rootScene);

      return server;
    }

    Server::Server(string name, double frameRate, Logger *logger):
      name(name), logger(logger), progressiveLoad(false), frameRate(frameRate)
    {
    }

    Server::~Server()
    {
      logger->log("No memory leak this time!");
    }

    void Server::refForwardDestroy()
    {
      //fontServer.reset();
      listener.reset();
      rootScene.reset();
      loader.reset(); // Should be last, since it waits for all jobs to complete
    }

    Ref<Loader> Server::getLoader() const
    {
      Mutex::Lock l(mutex);
      return loader;
    }

    void Server::setLoader(Ref<Loader> v)
    {
      Mutex::Lock l(mutex);
      loader = v;
    }

    /*
    Ref<FontServer> Server::getFontServer() const
    {
      Mutex::Lock l(mutex);
      return fontServer;
    }

    void Server::setFontServer(Ref<FontServer> v)
    {
      Mutex::Lock l(mutex);
      fontServer = v;
    }
    */

    Ref<Server::Listener> Server::getListener() const
    {
      Mutex::Lock l(mutex);
      return listener;
    }

    void Server::setListener(Ref<Listener> v)
    {
      Mutex::Lock l(mutex);
      listener = v;
    }

    Ref<Scene> Server::getRootScene() const
    {
      Mutex::Lock l(scenegraphMutex);
      return rootScene;
    }

    void Server::setRootScene(Ref<Scene> c)
    {
      if(c) c->realize();
      Mutex::Lock l(scenegraphMutex);
      rootScene = c;
    }

    void Server::setProgressiveLoad(bool v)
    {
      Mutex::Lock l(mutex);
      progressiveLoad = v;
    }

    bool Server::getProgressiveLoad() const
    {
      Mutex::Lock l(mutex);
      return progressiveLoad;
    }

    string Server::getName() const
    {
      Mutex::Lock l(mutex);
      return name;
    }

    Logger *Server::getLogger() const
    {
      Mutex::Lock l(mutex);
      return logger;
    }

    /*
    string Server::dumpScenegraph(ostream &out)
    {
      Mutex::Lock l(scenegraphMutex);
      SceneExporter::exportToVrml(RefArg<Server>(this, RefThisTag()), out);
    }
    */

    Time Server::getNextTimeStamp()
    {
      Mutex::Lock l(mutex);
      ++previousTimeStamp;
      Time t = Time::now();
      if(t > previousTimeStamp) previousTimeStamp = t;
      return previousTimeStamp;
    }

    void Server::add(ExecutionContext *c)
    {
      Mutex::Lock l(contextsMutex);
      contexts.push_back(c);
    }

    void Server::remove(ExecutionContext *c)
    {
      Mutex::Lock l(contextsMutex);
      contexts.remove(c);
    }

    void Server::tick()
    {
      list<Ref<ExecutionContext> > t;
      {
        Mutex::Lock l(contextsMutex);
        list<ExecutionContext *>::iterator i = contexts.begin();
        while(i != contexts.end())
        {
          Ref<ExecutionContext> r(*i, RefSafeIncTag());
          if(r) t.push_back(r);
          ++i;
        }
      }
      {
        list<Ref<ExecutionContext> >::iterator i = t.begin();
        while(i != t.end())
        {
          (*i)->tick();
          ++i;
        }
      }
    }
  }
}

---