core.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 <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/scene.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *MetadataObject::type  = 0;
    const NodeType *Node::type            = 0;
    const NodeType *ChildNode::type       = 0;
    const NodeType *SensorNode::type      = 0;
    const NodeType *MetadataDouble::type  = 0;
    const NodeType *MetadataFloat::type   = 0;
    const NodeType *MetadataInteger::type = 0;
    const NodeType *MetadataSet::type     = 0;
    const NodeType *MetadataString::type  = 0;

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


      // MetadataObject

      fields.push_back(newExposedField("name", SFString::type,
                                       &MetadataObject::name,
                                       &MetadataObject::nameChanged,
                                       &MetadataObject::nameStamp));
      fields.push_back(newExposedField("reference", SFString::type,
                                       &MetadataObject::reference,
                                       &MetadataObject::referenceChanged,
                                       &MetadataObject::referenceStamp));
      MetadataObject::type =
        NodeType::newAbstract("MetadataObject", false, &fields);
      fields.clear();


      // Node

      fields.push_back(newExposedField("metadata",
                                       &Node::metadata,
                                       &Node::metadataChanged,
                                       &Node::metadataStamp));
      Node::type =
        NodeType::newAbstract("Node", true, &fields);
      fields.clear();


      // ChildNode

      ChildNode::type =
        NodeType::newAbstract("ChildNode", true, 0, Node::type);


      // SensorNode

      fields.push_back(newExposedField("enabled", SFBool::type,
                                       &SensorNode::enabled,
                                       &SensorNode::enabledAssign,
                                       &SensorNode::enabledChanged,
                                       &SensorNode::enabledStamp));
      fields.push_back(newEventOut("isActive", SFBool::type,
                                   &SensorNode::isActive,
                                   &SensorNode::isActiveChanged));
      SensorNode::type =
        NodeType::newAbstract("SensorNode", false,
                              &fields, ChildNode::type);
      fields.clear();


      // MetadataDouble

      fields.push_back(newExposedField("value", MFDouble::type,
                                       &MetadataDouble::value,
                                       &MetadataDouble::valueChanged,
                                       &MetadataDouble::valueStamp));
      MetadataDouble::type =
        NodeType::newConcrete("MetadataDouble", "metadata",
                              MetadataDouble::instantiate, &fields,
                              Node::type, MetadataObject::type);
      fields.clear();


      // MetadataFloat

      fields.push_back(newExposedField("value", MFFloat::type,
                                       &MetadataFloat::value,
                                       &MetadataFloat::valueChanged,
                                       &MetadataFloat::valueStamp));
      MetadataFloat::type =
        NodeType::newConcrete("MetadataFloat", "metadata",
                              MetadataFloat::instantiate, &fields,
                              Node::type, MetadataObject::type);
      fields.clear();


      // MetadataInteger

      fields.push_back(newExposedField("value", MFInt32::type,
                                       &MetadataInteger::value,
                                       &MetadataInteger::valueChanged,
                                       &MetadataInteger::valueStamp));
      MetadataInteger::type =
        NodeType::newConcrete("MetadataInteger", "metadata",
                              MetadataInteger::instantiate, &fields,
                              Node::type, MetadataObject::type);
      fields.clear();


      // MetadataSet

      fields.push_back(newExposedField("value",
                                       &MetadataSet::value,
                                       &MetadataSet::valueChanged,
                                       &MetadataSet::valueStamp));
      MetadataSet::type =
        NodeType::newConcrete("MetadataSet", "metadata",
                              MetadataSet::instantiate, &fields,
                              Node::type, MetadataObject::type);
      fields.clear();


      // MetadataString

      fields.push_back(newExposedField("value", MFString::type,
                                       &MetadataString::value,
                                       &MetadataString::valueChanged,
                                       &MetadataString::valueStamp));
      MetadataString::type =
        NodeType::newConcrete("MetadataString", "metadata",
                              MetadataString::instantiate, &fields,
                              Node::type, MetadataObject::type);
      fields.clear();
    }

    bool SensorNode::enabledAssign(const bool &v, const Time &t)
    {
      enabled = v;
      enabledStamp = t;
      if(!v) onDisable();
      return true;
    }

    void SensorNode::onDisable()
    {
      if(!isActive) return;
      isActive = false;
      Event e(new SimpleValue<bool>(SFBool::type, isActive), enabledStamp);
      isActiveChanged.cascadeEvent(&e);
    }
  }
}

---