appear.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/appear.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *MaterialNode::type = 0;
    const NodeType *Material::type = 0;

    const NodeType *AppearanceNode::type = 0;
    const NodeType *Appearance::type = 0;

    const NodeType *BindableNode::type = 0;
    const NodeType *Fog::type = 0;
    const NodeType *Background::type = 0;

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


      // MaterialNode

      MaterialNode::type =
        NodeType::newAbstract("MaterialNode", false, 0,
                              AppearanceChildNode::type);


      // Material

      fields.push_back(newExposedField("ambientIntensity", SFFloat::type,
                                       &Material::ambientIntensity,
                                       &Material::ambientIntensityChanged,
                                       &Material::ambientIntensityStamp));
      fields.push_back(newExposedField("diffuseColor", SFColor::type,
                                       &Material::diffuseColor,
                                       &Material::diffuseColorChanged,
                                       &Material::diffuseColorStamp));
      fields.push_back(newExposedField("emissiveColor", SFColor::type,
                                       &Material::emissiveColor,
                                       &Material::emissiveColorChanged,
                                       &Material::emissiveColorStamp));
      fields.push_back(newExposedField("shininess", SFFloat::type,
                                       &Material::shininess,
                                       &Material::shininessChanged,
                                       &Material::shininessStamp));
      fields.push_back(newExposedField("specularColor", SFColor::type,
                                       &Material::specularColor,
                                       &Material::specularColorChanged,
                                       &Material::specularColorStamp));
      fields.push_back(newExposedField("transparency", SFFloat::type,
                                       &Material::transparency,
                                       &Material::transparencyChanged,
                                       &Material::transparencyStamp));
      fields.push_back(newExposedField("refractiveIndex", SFFloat::type,
                                       &Material::refractiveIndex,
                                       &Material::refractiveIndexChanged,
                                       &Material::refractiveIndexStamp));
      Material::type =
        NodeType::newConcrete("Material", "material",
                              Material::instantiate, &fields,
                              MaterialNode::type);
      fields.clear();



      // AppearanceNode

      AppearanceNode::type =
        NodeType::newAbstract("AppearanceNode", false, 0,
                              Node::type);


      // Appearance

      fields.push_back(newExposedField("material",
                                       &Appearance::material,
                                       &Appearance::materialChanged,
                                       &Appearance::materialStamp));
      fields.push_back(newExposedField("texture",
                                       &Appearance::texture,
                                       &Appearance::textureChanged,
                                       &Appearance::textureStamp));
      fields.push_back(newExposedField("textureTransform",
                                       &Appearance::textureTransform,
                                       &Appearance::textureTransformChanged,
                                       &Appearance::textureTransformStamp));
      Appearance::type =
        NodeType::newConcrete("Appearance", "appearance",
                              Appearance::instantiate, &fields,
                              AppearanceNode::type);
      fields.clear();



      // BindableNode

      fields.push_back(newEventIn("set_bind", SFBool::type,
                                  &BindableNode::setBind,
                                  &BindableNode::bindStamp));
      fields.push_back(newEventOut("isBound", SFBool::type,
                                   &BindableNode::isBound,
                                   &BindableNode::isBoundChanged));
      fields.push_back(newEventOut("bindTime", SFTime::type,
                                   &BindableNode::bindTime,
                                   &BindableNode::bindTimeChanged));
      BindableNode::type =
        NodeType::newAbstract("BindableNode", false, &fields,
                              ChildNode::type);
      fields.clear();


      // Fog

      /*
       * Note: 'set_bind' should have been an EventIn field - it is in
       * the VRML97 specification.
       */
      fields.push_back(newExposedField("color", SFColor::type,
                                       &Fog::color,
                                       &Fog::colorChanged,
                                       &Fog::colorStamp));
      fields.push_back(newExposedField("fogType", SFString::type,
                                       &Fog::fogType,
                                       &Fog::fogTypeChanged,
                                       &Fog::fogTypeStamp));
      fields.push_back(newExposedField("visibilityRange", SFFloat::type,
                                       &Fog::visibilityRange,
                                       &Fog::visibilityRangeChanged,
                                       &Fog::visibilityRangeStamp));
      Fog::type =
        NodeType::newConcrete("Fog", "children",
                              Fog::instantiate, &fields,
                              BindableNode::type);
      fields.clear();


      // Background

      fields.push_back(newExposedField("groundAngle", MFFloat::type,
                                       &Background::groundAngle,
                                       &Background::groundAngleChanged,
                                       &Background::groundAngleStamp));
      fields.push_back(newExposedField("groundColor", MFVec3f::type,
                                       &Background::groundColor,
                                       &Background::groundColorChanged,
                                       &Background::groundColorStamp));
      fields.push_back(newExposedField("backUrl", MFString::type,
                                       &Background::backUrl,
                                       &Background::backUrlChanged,
                                       &Background::backUrlStamp));
      fields.push_back(newExposedField("bottomUrl", MFString::type,
                                       &Background::bottomUrl,
                                       &Background::bottomUrlChanged,
                                       &Background::bottomUrlStamp));
      fields.push_back(newExposedField("frontUrl", MFString::type,
                                       &Background::frontUrl,
                                       &Background::frontUrlChanged,
                                       &Background::frontUrlStamp));
      fields.push_back(newExposedField("leftUrl", MFString::type,
                                       &Background::leftUrl,
                                       &Background::leftUrlChanged,
                                       &Background::leftUrlStamp));
      fields.push_back(newExposedField("rightUrl", MFString::type,
                                       &Background::rightUrl,
                                       &Background::rightUrlChanged,
                                       &Background::rightUrlStamp));
      fields.push_back(newExposedField("topUrl", MFString::type,
                                       &Background::topUrl,
                                       &Background::topUrlChanged,
                                       &Background::topUrlStamp));
      fields.push_back(newExposedField("skyAngle", MFFloat::type,
                                       &Background::skyAngle,
                                       &Background::skyAngleChanged,
                                       &Background::skyAngleStamp));
      fields.push_back(newExposedField("skyColor", MFVec3f::type,
                                       &Background::skyColor,
                                       &Background::skyColorChanged,
                                       &Background::skyColorStamp));
      Background::type =
        NodeType::newConcrete("Background", "children",
                              Background::instantiate, &fields,
                              BindableNode::type);
      fields.clear();
    }
  }
}

---