time.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 <math.h>

#include <iostream>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/time.H>
#include <archon/x3d/server/scene.H>
#include <archon/x3d/server/server.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *TimeDependentNode::type = 0;
    const NodeType *TimeSensor::type = 0;

    void initializeTimeComponent()
    {
      vector<const FieldBase *> fields;

      // TimeDependentNode

      fields.push_back(newEventOut("isPaused", SFBool::type,
                                   &TimeDependentNode::isPaused,
                                   &TimeDependentNode::isPausedChanged));
      fields.push_back(newEventOut("elapsedTime", SFTime::type,
                                   &TimeDependentNode::elapsedTime,
                                   &TimeDependentNode::elapsedTimeChanged));
      fields.push_back(newExposedField("loop", SFBool::type,
                                       &TimeDependentNode::loop,
                                       &TimeDependentNode::loopChanged,
                                       &TimeDependentNode::loopStamp));
      fields.push_back(newExposedField("numLoops", SFFloat::type,
                                       &TimeDependentNode::numLoops,
                                       &TimeDependentNode::numLoopsChanged,
                                       &TimeDependentNode::numLoopsStamp));
      fields.push_back(newExposedField("startTime", SFTime::type,
                                       &TimeDependentNode::startTime,
                                       &TimeDependentNode::startTimeChanged,
                                       &TimeDependentNode::startTimeStamp));
      fields.push_back(newExposedField("stopTime", SFTime::type,
                                       &TimeDependentNode::stopTime,
                                       &TimeDependentNode::stopTimeChanged,
                                       &TimeDependentNode::stopTimeStamp));
      fields.push_back(newExposedField("pauseTime", SFTime::type,
                                       &TimeDependentNode::pauseTime,
                                       &TimeDependentNode::pauseTimeChanged,
                                       &TimeDependentNode::pauseTimeStamp));
      fields.push_back(newExposedField("resumeTime", SFTime::type,
                                       &TimeDependentNode::resumeTime,
                                       &TimeDependentNode::resumeTimeChanged,
                                       &TimeDependentNode::resumeTimeStamp));
      TimeDependentNode::type =
        NodeType::newAbstract("TimeDependentNode", false,
                              &fields, ChildNode::type);
      fields.clear();


      // TimeSensor

      fields.push_back(newExposedField("cycleInterval", SFTime::type,
                                       &TimeSensor::cycleInterval,
                                       &TimeSensor::cycleIntervalChanged,
                                       &TimeSensor::cycleIntervalStamp));
      fields.push_back(newEventOut("cycleTime", SFTime::type,
                                   &TimeSensor::cycleTime,
                                   &TimeSensor::cycleTimeChanged));
      fields.push_back(newEventOut("fraction_changed", SFFloat::type,
                                   &TimeSensor::fraction,
                                   &TimeSensor::fractionChanged));
      fields.push_back(newEventOut("time", SFTime::type,
                                   &TimeSensor::time,
                                   &TimeSensor::timeChanged));
      TimeSensor::type =
        NodeType::newConcrete("TimeSensor", "children", TimeSensor::instantiate,
                              &fields, TimeDependentNode::type, SensorNode::type);
      fields.clear();
    }

    void TimeSensor::tick()
    {
      if(!getEnabled()) return;
      Time now = context->server->getNextTimeStamp();
      if(!isActive)
      {
        if(now<startTime ||
           now>=stopTime && stopTime > startTime ||
           now>=startTime+cycleInterval && !loop) return;

        // Activate
        isActive = true;

        // Skip an integer number of cycleInterval's so that we arrive
        // at the greatest cycleTime less than now. This seems to give
        // undesired effects for TimeSensors with startTime=0 (think
        // it over agian)
        long double phase;
        long double period;
        Time t=now-startTime;
        t.get(phase);
        cycleInterval.get(period);
        cycleTime = startTime + Time(floor(double(phase/period)) * double(period));

        {
          Event event(new SimpleValue<bool>(SFBool::type, isActive), now);
          isActiveChanged.cascadeEvent(&event);
        }
        {
          Event event(new SimpleValue<Time>(SFTime::type, cycleTime), now); 
          cycleTimeChanged.cascadeEvent(&event);
        }

        //cerr << "Activated '" << getName() << "'\n";
      }
      else if(now>=stopTime && stopTime > startTime ||
              now>=cycleTime+cycleInterval && !loop)
      {
        // Deactivate
        time = loop ? stopTime : min(stopTime, cycleTime+cycleInterval);
        fraction = 1;
        isActive = false;

        {
          Event event(new SimpleValue<Time>(SFTime::type, time), now); 
          timeChanged.cascadeEvent(&event);
        }
        {
          Event event(new SimpleValue<double>(SFFloat::type, fraction), now); 
          fractionChanged.cascadeEvent(&event);
        }
        {
          Event event(new SimpleValue<bool>(SFBool::type, isActive), now);
          isActiveChanged.cascadeEvent(&event);
        }
        //cerr << "De-activated '" << getName() << "'\n";
        return;
      }

      if(now>=cycleTime+cycleInterval)
      {
        // Next loop
        cycleTime += cycleInterval;

        Event event(new SimpleValue<Time>(SFTime::type, cycleTime), now); 
        cycleTimeChanged.cascadeEvent(&event);
      }

      long double phase;
      long double period;
      Time t = now-cycleTime;
      t.get(phase);
      cycleInterval.get(period);

      time = now;
      fraction = phase/period;

      {
        Event event(new SimpleValue<Time>(SFTime::type, time), now); 
        timeChanged.cascadeEvent(&event);
      }
      {
        Event event(new SimpleValue<double>(SFFloat::type, fraction), now); 
        fractionChanged.cascadeEvent(&event);
      }
    }
  }
}

---