node.autogen.H

/*
 * 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).
 */

/*
 * Note: This file is auto-generated, so don't edit it!
 */

#ifndef ARCHON_X3D_PROXY_NODE_AUTOGEN_H
#define ARCHON_X3D_PROXY_NODE_AUTOGEN_H

#include <archon/x3d/proxy/field_type.H>
#include <archon/x3d/proxy/field.H>

namespace Archon
{
  namespace X3D
  {
    namespace Proxy
    {
      struct MetadataObject: virtual NodeBase
      {
        InputOutput<SFString> name;
        InputOutput<SFString> reference;

        /*
         * name
         */
        std::string getName()
        {
          return name;
        }
        void setName(std::string v)
        {
          name = v;
        }

        /*
         * reference
         */
        std::string getReference()
        {
          return reference;
        }
        void setReference(std::string v)
        {
          reference = v;
        }

      protected:
        MetadataObject():
          name(this, 0),
          reference(this, 128) {}
      };



      struct Node: virtual NodeBase
      {
        InputOutput<SFNode<MetadataObject> > metadata;

        /*
         * metadata
         */
        Ref<MetadataObject> getMetadata()
        {
          return metadata;
        }
        void setMetadata(Ref<MetadataObject> v)
        {
          metadata = v;
        }

      protected:
        Node():
          metadata(this, 1) {}
      };



      struct ChildNode: virtual Node
      {
      protected:
        ChildNode() {}
      };



      struct SensorNode: virtual ChildNode
      {
        InputOutput<SFBool> enabled;
        OutputOnly<SFBool> isActive;

        /*
         * enabled
         */
        bool getEnabled()
        {
          return enabled;
        }
        void setEnabled(bool v)
        {
          enabled = v;
        }

        /*
         * isActive
         */
        bool getIsActive()
        {
          return isActive;
        }

      protected:
        SensorNode():
          enabled(this, 3),
          isActive(this, 131) {}
      };



      struct MetadataDouble: virtual Node, MetadataObject
      {
        static Ref<MetadataDouble> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<MetadataDouble>(c.get(), 4);
        }

        InputOutputSeq<MFDouble> value;

        /*
         * value
         */
        std::vector<double> getValue()
        {
          return value;
        }
        void setValue(const std::vector<double> &v)
        {
          value = v;
        }

      private:
        MetadataDouble(Session *s, unsigned long i): NodeBase(s, i),
          value(this, 4) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new MetadataDouble(s, i);
        }
      };



      struct MetadataFloat: virtual Node, MetadataObject
      {
        static Ref<MetadataFloat> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<MetadataFloat>(c.get(), 5);
        }

        InputOutputSeq<MFFloat> value;

        /*
         * value
         */
        std::vector<double> getValue()
        {
          return value;
        }
        void setValue(const std::vector<double> &v)
        {
          value = v;
        }

      private:
        MetadataFloat(Session *s, unsigned long i): NodeBase(s, i),
          value(this, 5) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new MetadataFloat(s, i);
        }
      };



      struct MetadataInteger: virtual Node, MetadataObject
      {
        static Ref<MetadataInteger> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<MetadataInteger>(c.get(), 6);
        }

        InputOutputSeq<MFInt32> value;

        /*
         * value
         */
        std::vector<int> getValue()
        {
          return value;
        }
        void setValue(const std::vector<int> &v)
        {
          value = v;
        }

      private:
        MetadataInteger(Session *s, unsigned long i): NodeBase(s, i),
          value(this, 6) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new MetadataInteger(s, i);
        }
      };



      struct MetadataSet: virtual Node, MetadataObject
      {
        static Ref<MetadataSet> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<MetadataSet>(c.get(), 7);
        }

        InputOutputSeq<MFNode<MetadataObject> > value;

        /*
         * value
         */
        std::vector<Ref<MetadataObject> > getValue()
        {
          return value;
        }
        void setValue(const std::vector<Ref<MetadataObject> > &v)
        {
          value = v;
        }

      private:
        MetadataSet(Session *s, unsigned long i): NodeBase(s, i),
          value(this, 7) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new MetadataSet(s, i);
        }
      };



      struct MetadataString: virtual Node, MetadataObject
      {
        static Ref<MetadataString> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<MetadataString>(c.get(), 8);
        }

        InputOutputSeq<MFString> value;

        /*
         * value
         */
        std::vector<std::string> getValue()
        {
          return value;
        }
        void setValue(const std::vector<std::string> &v)
        {
          value = v;
        }

      private:
        MetadataString(Session *s, unsigned long i): NodeBase(s, i),
          value(this, 8) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new MetadataString(s, i);
        }
      };



      struct TimeDependentNode: virtual ChildNode
      {
        OutputOnly<SFBool> isPaused;
        OutputOnly<SFTime> elapsedTime;
        InputOutput<SFBool> loop;
        InputOutput<SFFloat> numLoops;
        InputOutput<SFTime> startTime;
        InputOutput<SFTime> stopTime;
        InputOutput<SFTime> pauseTime;
        InputOutput<SFTime> resumeTime;

        /*
         * isPaused
         */
        bool getIsPaused()
        {
          return isPaused;
        }

        /*
         * elapsedTime
         */
        Time getElapsedTime()
        {
          return elapsedTime;
        }

        /*
         * loop
         */
        bool getLoop()
        {
          return loop;
        }
        void setLoop(bool v)
        {
          loop = v;
        }

        /*
         * numLoops
         */
        double getNumLoops()
        {
          return numLoops;
        }
        void setNumLoops(double v)
        {
          numLoops = v;
        }

        /*
         * startTime
         */
        Time getStartTime()
        {
          return startTime;
        }
        void setStartTime(Time v)
        {
          startTime = v;
        }

        /*
         * stopTime
         */
        Time getStopTime()
        {
          return stopTime;
        }
        void setStopTime(Time v)
        {
          stopTime = v;
        }

        /*
         * pauseTime
         */
        Time getPauseTime()
        {
          return pauseTime;
        }
        void setPauseTime(Time v)
        {
          pauseTime = v;
        }

        /*
         * resumeTime
         */
        Time getResumeTime()
        {
          return resumeTime;
        }
        void setResumeTime(Time v)
        {
          resumeTime = v;
        }

      protected:
        TimeDependentNode():
          isPaused(this, 9),
          elapsedTime(this, 137),
          loop(this, 265),
          numLoops(this, 393),
          startTime(this, 521),
          stopTime(this, 649),
          pauseTime(this, 777),
          resumeTime(this, 905) {}
      };



      struct TimeSensor: TimeDependentNode, SensorNode
      {
        static Ref<TimeSensor> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<TimeSensor>(c.get(), 10);
        }

        InputOutput<SFTime> cycleInterval;
        OutputOnly<SFTime> cycleTime;
        OutputOnly<SFFloat> fraction_changed;
        OutputOnly<SFTime> time;

        /*
         * cycleInterval
         */
        Time getCycleInterval()
        {
          return cycleInterval;
        }
        void setCycleInterval(Time v)
        {
          cycleInterval = v;
        }

        /*
         * cycleTime
         */
        Time getCycleTime()
        {
          return cycleTime;
        }

        /*
         * fraction_changed
         */
        double getFraction_changed()
        {
          return fraction_changed;
        }

        /*
         * time
         */
        Time getTime()
        {
          return time;
        }

      private:
        TimeSensor(Session *s, unsigned long i): NodeBase(s, i),
          cycleInterval(this, 10),
          cycleTime(this, 138),
          fraction_changed(this, 266),
          time(this, 394) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new TimeSensor(s, i);
        }
      };



      struct UrlObject: virtual NodeBase
      {
        InputOutputSeq<MFString> url;

        /*
         * url
         */
        std::vector<std::string> getUrl()
        {
          return url;
        }
        void setUrl(const std::vector<std::string> &v)
        {
          url = v;
        }

      protected:
        UrlObject():
          url(this, 11) {}
      };



      struct SubSceneNode: virtual ChildNode
      {
      protected:
        SubSceneNode() {}
      };



      struct Inline: SubSceneNode, UrlObject
      {
        static Ref<Inline> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Inline>(c.get(), 13);
        }

        InputOutput<SFBool> load;

        /*
         * load
         */
        bool getLoad()
        {
          return load;
        }
        void setLoad(bool v)
        {
          load = v;
        }

      private:
        Inline(Session *s, unsigned long i): NodeBase(s, i),
          load(this, 13) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Inline(s, i);
        }
      };



      struct ApplicationLink: SubSceneNode
      {
        static Ref<ApplicationLink> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ApplicationLink>(c.get(), 14);
        }

      private:
        ApplicationLink(Session *s, unsigned long i): NodeBase(s, i) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ApplicationLink(s, i);
        }
      };



      struct BoundedObject: virtual NodeBase
      {
        InitializeOnly<SFVec3f> bboxCenter;
        InitializeOnly<SFVec3f> bboxSize;

        /*
         * bboxCenter
         */
        Vector3 getBboxCenter()
        {
          return bboxCenter;
        }
        void setBboxCenter(Vector3 v)
        {
          bboxCenter = v;
        }

        /*
         * bboxSize
         */
        Vector3 getBboxSize()
        {
          return bboxSize;
        }
        void setBboxSize(Vector3 v)
        {
          bboxSize = v;
        }

      protected:
        BoundedObject():
          bboxCenter(this, 15),
          bboxSize(this, 143) {}
      };



      struct GroupingNode: virtual ChildNode
      {
        InputOnlySeq<MFNode<ChildNode> > addChildren;
        InputOnlySeq<MFNode<ChildNode> > removeChildren;
        InputOutputSeq<MFNode<ChildNode> > children;

        /*
         * addChildren
         */
        void setAddChildren(const std::vector<Ref<ChildNode> > &v)
        {
          addChildren = v;
        }

        /*
         * removeChildren
         */
        void setRemoveChildren(const std::vector<Ref<ChildNode> > &v)
        {
          removeChildren = v;
        }

        /*
         * children
         */
        std::vector<Ref<ChildNode> > getChildren()
        {
          return children;
        }
        void setChildren(const std::vector<Ref<ChildNode> > &v)
        {
          children = v;
        }

      protected:
        GroupingNode():
          addChildren(this, 16),
          removeChildren(this, 144),
          children(this, 272) {}
      };



      struct Group: GroupingNode, BoundedObject
      {
        static Ref<Group> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Group>(c.get(), 17);
        }

      private:
        Group(Session *s, unsigned long i): NodeBase(s, i) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Group(s, i);
        }
      };



      struct Switch: GroupingNode, BoundedObject
      {
        static Ref<Switch> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Switch>(c.get(), 18);
        }

        InputOutput<SFInt32> whichChoice;

        /*
         * whichChoice
         */
        int getWhichChoice()
        {
          return whichChoice;
        }
        void setWhichChoice(int v)
        {
          whichChoice = v;
        }

      private:
        Switch(Session *s, unsigned long i): NodeBase(s, i),
          whichChoice(this, 18) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Switch(s, i);
        }
      };



      struct Transform: GroupingNode, BoundedObject
      {
        static Ref<Transform> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Transform>(c.get(), 19);
        }

        InputOutput<SFVec3f> center;
        InputOutput<SFRotation> rotation;
        InputOutput<SFVec3f> scale;
        InputOutput<SFRotation> scaleOrientation;
        InputOutput<SFVec3f> translation;

        /*
         * center
         */
        Vector3 getCenter()
        {
          return center;
        }
        void setCenter(Vector3 v)
        {
          center = v;
        }

        /*
         * rotation
         */
        Rotation3 getRotation()
        {
          return rotation;
        }
        void setRotation(Rotation3 v)
        {
          rotation = v;
        }

        /*
         * scale
         */
        Vector3 getScale()
        {
          return scale;
        }
        void setScale(Vector3 v)
        {
          scale = v;
        }

        /*
         * scaleOrientation
         */
        Rotation3 getScaleOrientation()
        {
          return scaleOrientation;
        }
        void setScaleOrientation(Rotation3 v)
        {
          scaleOrientation = v;
        }

        /*
         * translation
         */
        Vector3 getTranslation()
        {
          return translation;
        }
        void setTranslation(Vector3 v)
        {
          translation = v;
        }

      private:
        Transform(Session *s, unsigned long i): NodeBase(s, i),
          center(this, 19),
          rotation(this, 147),
          scale(this, 275),
          scaleOrientation(this, 403),
          translation(this, 531) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Transform(s, i);
        }
      };



      struct GeometricPropertyNode: virtual Node
      {
      protected:
        GeometricPropertyNode() {}
      };



      struct ColorNode: GeometricPropertyNode
      {
      protected:
        ColorNode() {}
      };



      struct CoordinateNode: GeometricPropertyNode
      {
      protected:
        CoordinateNode() {}
      };



      struct NormalNode: GeometricPropertyNode
      {
      protected:
        NormalNode() {}
      };



      struct Color: ColorNode
      {
        static Ref<Color> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Color>(c.get(), 24);
        }

        InputOutputSeq<MFColor> color;

        /*
         * color
         */
        std::vector<Vector3> getColor()
        {
          return color;
        }
        void setColor(const std::vector<Vector3> &v)
        {
          color = v;
        }

      private:
        Color(Session *s, unsigned long i): NodeBase(s, i),
          color(this, 24) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Color(s, i);
        }
      };



      struct ColorRGBA: ColorNode
      {
        static Ref<ColorRGBA> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ColorRGBA>(c.get(), 25);
        }

        InputOutputSeq<MFColorRGBA> color;

        /*
         * color
         */
        std::vector<Vector4> getColor()
        {
          return color;
        }
        void setColor(const std::vector<Vector4> &v)
        {
          color = v;
        }

      private:
        ColorRGBA(Session *s, unsigned long i): NodeBase(s, i),
          color(this, 25) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ColorRGBA(s, i);
        }
      };



      struct Coordinate: CoordinateNode
      {
        static Ref<Coordinate> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Coordinate>(c.get(), 26);
        }

        InputOutputSeq<MFVec3f> point;

        /*
         * point
         */
        std::vector<Vector3> getPoint()
        {
          return point;
        }
        void setPoint(const std::vector<Vector3> &v)
        {
          point = v;
        }

      private:
        Coordinate(Session *s, unsigned long i): NodeBase(s, i),
          point(this, 26) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Coordinate(s, i);
        }
      };



      struct Normal: NormalNode
      {
        static Ref<Normal> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Normal>(c.get(), 27);
        }

        InputOutputSeq<MFVec3f> vector;

        /*
         * vector
         */
        std::vector<Vector3> getVector()
        {
          return vector;
        }
        void setVector(const std::vector<Vector3> &v)
        {
          vector = v;
        }

      private:
        Normal(Session *s, unsigned long i): NodeBase(s, i),
          vector(this, 27) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Normal(s, i);
        }
      };



      struct TextureCoordinateNode: GeometricPropertyNode
      {
      protected:
        TextureCoordinateNode() {}
      };



      struct TextureCoordinate: TextureCoordinateNode
      {
        static Ref<TextureCoordinate> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<TextureCoordinate>(c.get(), 29);
        }

        InputOutputSeq<MFVec2f> point;

        /*
         * point
         */
        std::vector<Vector2> getPoint()
        {
          return point;
        }
        void setPoint(const std::vector<Vector2> &v)
        {
          point = v;
        }

      private:
        TextureCoordinate(Session *s, unsigned long i): NodeBase(s, i),
          point(this, 29) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new TextureCoordinate(s, i);
        }
      };



      struct AppearanceChildNode: virtual Node
      {
      protected:
        AppearanceChildNode() {}
      };



      struct TextureTransformNode: AppearanceChildNode
      {
      protected:
        TextureTransformNode() {}
      };



      struct TextureTransform: TextureTransformNode
      {
        static Ref<TextureTransform> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<TextureTransform>(c.get(), 32);
        }

        InputOutput<SFVec2f> center;
        InputOutput<SFFloat> rotation;
        InputOutput<SFVec2f> scale;
        InputOutput<SFVec2f> translation;

        /*
         * center
         */
        Vector2 getCenter()
        {
          return center;
        }
        void setCenter(Vector2 v)
        {
          center = v;
        }

        /*
         * rotation
         */
        double getRotation()
        {
          return rotation;
        }
        void setRotation(double v)
        {
          rotation = v;
        }

        /*
         * scale
         */
        Vector2 getScale()
        {
          return scale;
        }
        void setScale(Vector2 v)
        {
          scale = v;
        }

        /*
         * translation
         */
        Vector2 getTranslation()
        {
          return translation;
        }
        void setTranslation(Vector2 v)
        {
          translation = v;
        }

      private:
        TextureTransform(Session *s, unsigned long i): NodeBase(s, i),
          center(this, 32),
          rotation(this, 160),
          scale(this, 288),
          translation(this, 416) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new TextureTransform(s, i);
        }
      };



      struct TextureNode: AppearanceChildNode
      {
      protected:
        TextureNode() {}
      };



      struct Texture2DNode: TextureNode
      {
        InitializeOnly<SFBool> repeatS;
        InitializeOnly<SFBool> repeatT;

        /*
         * repeatS
         */
        bool getRepeatS()
        {
          return repeatS;
        }
        void setRepeatS(bool v)
        {
          repeatS = v;
        }

        /*
         * repeatT
         */
        bool getRepeatT()
        {
          return repeatT;
        }
        void setRepeatT(bool v)
        {
          repeatT = v;
        }

      protected:
        Texture2DNode():
          repeatS(this, 34),
          repeatT(this, 162) {}
      };



      struct ImageTexture: Texture2DNode, UrlObject
      {
        static Ref<ImageTexture> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ImageTexture>(c.get(), 35);
        }

      private:
        ImageTexture(Session *s, unsigned long i): NodeBase(s, i) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ImageTexture(s, i);
        }
      };



      struct PixelTexture: Texture2DNode
      {
        static Ref<PixelTexture> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PixelTexture>(c.get(), 36);
        }

        InputOutput<SFImage> image;

        /*
         * image
         */
        Image getImage()
        {
          return image;
        }
        void setImage(const Image &v)
        {
          image = v;
        }

      private:
        PixelTexture(Session *s, unsigned long i): NodeBase(s, i),
          image(this, 36) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PixelTexture(s, i);
        }
      };



      struct MaterialNode: AppearanceChildNode
      {
      protected:
        MaterialNode() {}
      };



      struct Material: MaterialNode
      {
        static Ref<Material> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Material>(c.get(), 38);
        }

        InputOutput<SFFloat> ambientIntensity;
        InputOutput<SFColor> diffuseColor;
        InputOutput<SFColor> emissiveColor;
        InputOutput<SFFloat> shininess;
        InputOutput<SFColor> specularColor;
        InputOutput<SFFloat> transparency;
        InputOutput<SFFloat> refractiveIndex;

        /*
         * ambientIntensity
         */
        double getAmbientIntensity()
        {
          return ambientIntensity;
        }
        void setAmbientIntensity(double v)
        {
          ambientIntensity = v;
        }

        /*
         * diffuseColor
         */
        Vector3 getDiffuseColor()
        {
          return diffuseColor;
        }
        void setDiffuseColor(Vector3 v)
        {
          diffuseColor = v;
        }

        /*
         * emissiveColor
         */
        Vector3 getEmissiveColor()
        {
          return emissiveColor;
        }
        void setEmissiveColor(Vector3 v)
        {
          emissiveColor = v;
        }

        /*
         * shininess
         */
        double getShininess()
        {
          return shininess;
        }
        void setShininess(double v)
        {
          shininess = v;
        }

        /*
         * specularColor
         */
        Vector3 getSpecularColor()
        {
          return specularColor;
        }
        void setSpecularColor(Vector3 v)
        {
          specularColor = v;
        }

        /*
         * transparency
         */
        double getTransparency()
        {
          return transparency;
        }
        void setTransparency(double v)
        {
          transparency = v;
        }

        /*
         * refractiveIndex
         */
        double getRefractiveIndex()
        {
          return refractiveIndex;
        }
        void setRefractiveIndex(double v)
        {
          refractiveIndex = v;
        }

      private:
        Material(Session *s, unsigned long i): NodeBase(s, i),
          ambientIntensity(this, 38),
          diffuseColor(this, 166),
          emissiveColor(this, 294),
          shininess(this, 422),
          specularColor(this, 550),
          transparency(this, 678),
          refractiveIndex(this, 806) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Material(s, i);
        }
      };



      struct AppearanceNode: virtual Node
      {
      protected:
        AppearanceNode() {}
      };



      struct Appearance: AppearanceNode
      {
        static Ref<Appearance> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Appearance>(c.get(), 40);
        }

        InputOutput<SFNode<MaterialNode> > material;
        InputOutput<SFNode<TextureNode> > texture;
        InputOutput<SFNode<TextureTransformNode> > textureTransform;

        /*
         * material
         */
        Ref<MaterialNode> getMaterial()
        {
          return material;
        }
        void setMaterial(Ref<MaterialNode> v)
        {
          material = v;
        }

        /*
         * texture
         */
        Ref<TextureNode> getTexture()
        {
          return texture;
        }
        void setTexture(Ref<TextureNode> v)
        {
          texture = v;
        }

        /*
         * textureTransform
         */
        Ref<TextureTransformNode> getTextureTransform()
        {
          return textureTransform;
        }
        void setTextureTransform(Ref<TextureTransformNode> v)
        {
          textureTransform = v;
        }

      private:
        Appearance(Session *s, unsigned long i): NodeBase(s, i),
          material(this, 40),
          texture(this, 168),
          textureTransform(this, 296) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Appearance(s, i);
        }
      };



      struct BindableNode: virtual ChildNode
      {
        InputOnly<SFBool> set_bind;
        OutputOnly<SFBool> isBound;
        OutputOnly<SFTime> bindTime;

        /*
         * set_bind
         */
        void setSet_bind(bool v)
        {
          set_bind = v;
        }

        /*
         * isBound
         */
        bool getIsBound()
        {
          return isBound;
        }

        /*
         * bindTime
         */
        Time getBindTime()
        {
          return bindTime;
        }

      protected:
        BindableNode():
          set_bind(this, 41),
          isBound(this, 169),
          bindTime(this, 297) {}
      };



      struct Fog: BindableNode
      {
        static Ref<Fog> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Fog>(c.get(), 42);
        }

        InputOutput<SFColor> color;
        InputOutput<SFString> fogType;
        InputOutput<SFFloat> visibilityRange;

        /*
         * color
         */
        Vector3 getColor()
        {
          return color;
        }
        void setColor(Vector3 v)
        {
          color = v;
        }

        /*
         * fogType
         */
        std::string getFogType()
        {
          return fogType;
        }
        void setFogType(std::string v)
        {
          fogType = v;
        }

        /*
         * visibilityRange
         */
        double getVisibilityRange()
        {
          return visibilityRange;
        }
        void setVisibilityRange(double v)
        {
          visibilityRange = v;
        }

      private:
        Fog(Session *s, unsigned long i): NodeBase(s, i),
          color(this, 42),
          fogType(this, 170),
          visibilityRange(this, 298) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Fog(s, i);
        }
      };



      struct Background: BindableNode
      {
        static Ref<Background> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Background>(c.get(), 43);
        }

        InputOutputSeq<MFFloat> groundAngle;
        InputOutputSeq<MFVec3f> groundColor;
        InputOutputSeq<MFString> backUrl;
        InputOutputSeq<MFString> bottomUrl;
        InputOutputSeq<MFString> frontUrl;
        InputOutputSeq<MFString> leftUrl;
        InputOutputSeq<MFString> rightUrl;
        InputOutputSeq<MFString> topUrl;
        InputOutputSeq<MFFloat> skyAngle;
        InputOutputSeq<MFVec3f> skyColor;

        /*
         * groundAngle
         */
        std::vector<double> getGroundAngle()
        {
          return groundAngle;
        }
        void setGroundAngle(const std::vector<double> &v)
        {
          groundAngle = v;
        }

        /*
         * groundColor
         */
        std::vector<Vector3> getGroundColor()
        {
          return groundColor;
        }
        void setGroundColor(const std::vector<Vector3> &v)
        {
          groundColor = v;
        }

        /*
         * backUrl
         */
        std::vector<std::string> getBackUrl()
        {
          return backUrl;
        }
        void setBackUrl(const std::vector<std::string> &v)
        {
          backUrl = v;
        }

        /*
         * bottomUrl
         */
        std::vector<std::string> getBottomUrl()
        {
          return bottomUrl;
        }
        void setBottomUrl(const std::vector<std::string> &v)
        {
          bottomUrl = v;
        }

        /*
         * frontUrl
         */
        std::vector<std::string> getFrontUrl()
        {
          return frontUrl;
        }
        void setFrontUrl(const std::vector<std::string> &v)
        {
          frontUrl = v;
        }

        /*
         * leftUrl
         */
        std::vector<std::string> getLeftUrl()
        {
          return leftUrl;
        }
        void setLeftUrl(const std::vector<std::string> &v)
        {
          leftUrl = v;
        }

        /*
         * rightUrl
         */
        std::vector<std::string> getRightUrl()
        {
          return rightUrl;
        }
        void setRightUrl(const std::vector<std::string> &v)
        {
          rightUrl = v;
        }

        /*
         * topUrl
         */
        std::vector<std::string> getTopUrl()
        {
          return topUrl;
        }
        void setTopUrl(const std::vector<std::string> &v)
        {
          topUrl = v;
        }

        /*
         * skyAngle
         */
        std::vector<double> getSkyAngle()
        {
          return skyAngle;
        }
        void setSkyAngle(const std::vector<double> &v)
        {
          skyAngle = v;
        }

        /*
         * skyColor
         */
        std::vector<Vector3> getSkyColor()
        {
          return skyColor;
        }
        void setSkyColor(const std::vector<Vector3> &v)
        {
          skyColor = v;
        }

      private:
        Background(Session *s, unsigned long i): NodeBase(s, i),
          groundAngle(this, 43),
          groundColor(this, 171),
          backUrl(this, 299),
          bottomUrl(this, 427),
          frontUrl(this, 555),
          leftUrl(this, 683),
          rightUrl(this, 811),
          topUrl(this, 939),
          skyAngle(this, 1067),
          skyColor(this, 1195) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Background(s, i);
        }
      };



      struct GeometryNode: virtual Node
      {
      protected:
        GeometryNode() {}
      };



      struct Geometry3DNode: GeometryNode
      {
      protected:
        Geometry3DNode() {}
      };



      struct Box: Geometry3DNode
      {
        static Ref<Box> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Box>(c.get(), 46);
        }

        InitializeOnly<SFVec3f> size;

        /*
         * size
         */
        Vector3 getSize()
        {
          return size;
        }
        void setSize(Vector3 v)
        {
          size = v;
        }

      private:
        Box(Session *s, unsigned long i): NodeBase(s, i),
          size(this, 46) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Box(s, i);
        }
      };



      struct Cone: Geometry3DNode
      {
        static Ref<Cone> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Cone>(c.get(), 47);
        }

        InitializeOnly<SFFloat> bottomRadius;
        InitializeOnly<SFFloat> height;
        InitializeOnly<SFBool> side;
        InitializeOnly<SFBool> bottom;

        /*
         * bottomRadius
         */
        double getBottomRadius()
        {
          return bottomRadius;
        }
        void setBottomRadius(double v)
        {
          bottomRadius = v;
        }

        /*
         * height
         */
        double getHeight()
        {
          return height;
        }
        void setHeight(double v)
        {
          height = v;
        }

        /*
         * side
         */
        bool getSide()
        {
          return side;
        }
        void setSide(bool v)
        {
          side = v;
        }

        /*
         * bottom
         */
        bool getBottom()
        {
          return bottom;
        }
        void setBottom(bool v)
        {
          bottom = v;
        }

      private:
        Cone(Session *s, unsigned long i): NodeBase(s, i),
          bottomRadius(this, 47),
          height(this, 175),
          side(this, 303),
          bottom(this, 431) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Cone(s, i);
        }
      };



      struct Cylinder: Geometry3DNode
      {
        static Ref<Cylinder> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Cylinder>(c.get(), 48);
        }

        InitializeOnly<SFBool> bottom;
        InitializeOnly<SFFloat> radius;
        InitializeOnly<SFFloat> height;
        InitializeOnly<SFBool> side;
        InitializeOnly<SFBool> top;

        /*
         * bottom
         */
        bool getBottom()
        {
          return bottom;
        }
        void setBottom(bool v)
        {
          bottom = v;
        }

        /*
         * radius
         */
        double getRadius()
        {
          return radius;
        }
        void setRadius(double v)
        {
          radius = v;
        }

        /*
         * height
         */
        double getHeight()
        {
          return height;
        }
        void setHeight(double v)
        {
          height = v;
        }

        /*
         * side
         */
        bool getSide()
        {
          return side;
        }
        void setSide(bool v)
        {
          side = v;
        }

        /*
         * top
         */
        bool getTop()
        {
          return top;
        }
        void setTop(bool v)
        {
          top = v;
        }

      private:
        Cylinder(Session *s, unsigned long i): NodeBase(s, i),
          bottom(this, 48),
          radius(this, 176),
          height(this, 304),
          side(this, 432),
          top(this, 560) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Cylinder(s, i);
        }
      };



      struct IndexedLineSet: Geometry3DNode
      {
        static Ref<IndexedLineSet> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<IndexedLineSet>(c.get(), 49);
        }

        InputOutput<SFNode<ColorNode> > color;
        InputOutput<SFNode<CoordinateNode> > coord;
        InitializeOnlySeq<MFInt32> colorIndex;
        InputOnlySeq<MFInt32> set_colorIndex;
        InitializeOnly<SFBool> colorPerVertex;
        InitializeOnlySeq<MFInt32> coordIndex;
        InputOnlySeq<MFInt32> set_coordIndex;
        InitializeOnly<SFFloat> lineWidth;

        /*
         * color
         */
        Ref<ColorNode> getColor()
        {
          return color;
        }
        void setColor(Ref<ColorNode> v)
        {
          color = v;
        }

        /*
         * coord
         */
        Ref<CoordinateNode> getCoord()
        {
          return coord;
        }
        void setCoord(Ref<CoordinateNode> v)
        {
          coord = v;
        }

        /*
         * colorIndex
         */
        std::vector<int> getColorIndex()
        {
          return colorIndex;
        }
        void setColorIndex(const std::vector<int> &v)
        {
          colorIndex = v;
        }

        /*
         * set_colorIndex
         */
        void setSet_colorIndex(const std::vector<int> &v)
        {
          set_colorIndex = v;
        }

        /*
         * colorPerVertex
         */
        bool getColorPerVertex()
        {
          return colorPerVertex;
        }
        void setColorPerVertex(bool v)
        {
          colorPerVertex = v;
        }

        /*
         * coordIndex
         */
        std::vector<int> getCoordIndex()
        {
          return coordIndex;
        }
        void setCoordIndex(const std::vector<int> &v)
        {
          coordIndex = v;
        }

        /*
         * set_coordIndex
         */
        void setSet_coordIndex(const std::vector<int> &v)
        {
          set_coordIndex = v;
        }

        /*
         * lineWidth
         */
        double getLineWidth()
        {
          return lineWidth;
        }
        void setLineWidth(double v)
        {
          lineWidth = v;
        }

      private:
        IndexedLineSet(Session *s, unsigned long i): NodeBase(s, i),
          color(this, 49),
          coord(this, 177),
          colorIndex(this, 305),
          set_colorIndex(this, 433),
          colorPerVertex(this, 561),
          coordIndex(this, 689),
          set_coordIndex(this, 817),
          lineWidth(this, 945) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new IndexedLineSet(s, i);
        }
      };



      struct PointSet: Geometry3DNode
      {
        static Ref<PointSet> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PointSet>(c.get(), 50);
        }

        InputOutput<SFNode<ColorNode> > color;
        InputOutput<SFNode<CoordinateNode> > coord;

        /*
         * color
         */
        Ref<ColorNode> getColor()
        {
          return color;
        }
        void setColor(Ref<ColorNode> v)
        {
          color = v;
        }

        /*
         * coord
         */
        Ref<CoordinateNode> getCoord()
        {
          return coord;
        }
        void setCoord(Ref<CoordinateNode> v)
        {
          coord = v;
        }

      private:
        PointSet(Session *s, unsigned long i): NodeBase(s, i),
          color(this, 50),
          coord(this, 178) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PointSet(s, i);
        }
      };



      struct Sphere: Geometry3DNode
      {
        static Ref<Sphere> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Sphere>(c.get(), 51);
        }

        InitializeOnly<SFFloat> radius;

        /*
         * radius
         */
        double getRadius()
        {
          return radius;
        }
        void setRadius(double v)
        {
          radius = v;
        }

      private:
        Sphere(Session *s, unsigned long i): NodeBase(s, i),
          radius(this, 51) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Sphere(s, i);
        }
      };



      struct ComposedGeometryNode: Geometry3DNode
      {
        InputOutput<SFNode<ColorNode> > color;
        InputOutput<SFNode<CoordinateNode> > coord;
        InputOutput<SFNode<NormalNode> > normal;
        InputOutput<SFNode<TextureCoordinateNode> > texCoord;
        InitializeOnly<SFBool> ccw;
        InitializeOnly<SFBool> colorPerVertex;
        InitializeOnly<SFBool> normalPerVertex;
        InitializeOnly<SFBool> solid;

        /*
         * color
         */
        Ref<ColorNode> getColor()
        {
          return color;
        }
        void setColor(Ref<ColorNode> v)
        {
          color = v;
        }

        /*
         * coord
         */
        Ref<CoordinateNode> getCoord()
        {
          return coord;
        }
        void setCoord(Ref<CoordinateNode> v)
        {
          coord = v;
        }

        /*
         * normal
         */
        Ref<NormalNode> getNormal()
        {
          return normal;
        }
        void setNormal(Ref<NormalNode> v)
        {
          normal = v;
        }

        /*
         * texCoord
         */
        Ref<TextureCoordinateNode> getTexCoord()
        {
          return texCoord;
        }
        void setTexCoord(Ref<TextureCoordinateNode> v)
        {
          texCoord = v;
        }

        /*
         * ccw
         */
        bool getCcw()
        {
          return ccw;
        }
        void setCcw(bool v)
        {
          ccw = v;
        }

        /*
         * colorPerVertex
         */
        bool getColorPerVertex()
        {
          return colorPerVertex;
        }
        void setColorPerVertex(bool v)
        {
          colorPerVertex = v;
        }

        /*
         * normalPerVertex
         */
        bool getNormalPerVertex()
        {
          return normalPerVertex;
        }
        void setNormalPerVertex(bool v)
        {
          normalPerVertex = v;
        }

        /*
         * solid
         */
        bool getSolid()
        {
          return solid;
        }
        void setSolid(bool v)
        {
          solid = v;
        }

      protected:
        ComposedGeometryNode():
          color(this, 52),
          coord(this, 180),
          normal(this, 308),
          texCoord(this, 436),
          ccw(this, 564),
          colorPerVertex(this, 692),
          normalPerVertex(this, 820),
          solid(this, 948) {}
      };



      struct IndexedFaceSet: ComposedGeometryNode
      {
        static Ref<IndexedFaceSet> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<IndexedFaceSet>(c.get(), 53);
        }

        InitializeOnly<SFBool> convex;
        InitializeOnlySeq<MFInt32> colorIndex;
        InputOnlySeq<MFInt32> set_colorIndex;
        InitializeOnlySeq<MFInt32> coordIndex;
        InputOnlySeq<MFInt32> set_coordIndex;
        InitializeOnly<SFFloat> creaseAngle;
        InitializeOnlySeq<MFInt32> normalIndex;
        InputOnlySeq<MFInt32> set_normalIndex;
        InitializeOnlySeq<MFInt32> texCoordIndex;
        InputOnlySeq<MFInt32> set_texCoordIndex;

        /*
         * convex
         */
        bool getConvex()
        {
          return convex;
        }
        void setConvex(bool v)
        {
          convex = v;
        }

        /*
         * colorIndex
         */
        std::vector<int> getColorIndex()
        {
          return colorIndex;
        }
        void setColorIndex(const std::vector<int> &v)
        {
          colorIndex = v;
        }

        /*
         * set_colorIndex
         */
        void setSet_colorIndex(const std::vector<int> &v)
        {
          set_colorIndex = v;
        }

        /*
         * coordIndex
         */
        std::vector<int> getCoordIndex()
        {
          return coordIndex;
        }
        void setCoordIndex(const std::vector<int> &v)
        {
          coordIndex = v;
        }

        /*
         * set_coordIndex
         */
        void setSet_coordIndex(const std::vector<int> &v)
        {
          set_coordIndex = v;
        }

        /*
         * creaseAngle
         */
        double getCreaseAngle()
        {
          return creaseAngle;
        }
        void setCreaseAngle(double v)
        {
          creaseAngle = v;
        }

        /*
         * normalIndex
         */
        std::vector<int> getNormalIndex()
        {
          return normalIndex;
        }
        void setNormalIndex(const std::vector<int> &v)
        {
          normalIndex = v;
        }

        /*
         * set_normalIndex
         */
        void setSet_normalIndex(const std::vector<int> &v)
        {
          set_normalIndex = v;
        }

        /*
         * texCoordIndex
         */
        std::vector<int> getTexCoordIndex()
        {
          return texCoordIndex;
        }
        void setTexCoordIndex(const std::vector<int> &v)
        {
          texCoordIndex = v;
        }

        /*
         * set_texCoordIndex
         */
        void setSet_texCoordIndex(const std::vector<int> &v)
        {
          set_texCoordIndex = v;
        }

      private:
        IndexedFaceSet(Session *s, unsigned long i): NodeBase(s, i),
          convex(this, 53),
          colorIndex(this, 181),
          set_colorIndex(this, 309),
          coordIndex(this, 437),
          set_coordIndex(this, 565),
          creaseAngle(this, 693),
          normalIndex(this, 821),
          set_normalIndex(this, 949),
          texCoordIndex(this, 1077),
          set_texCoordIndex(this, 1205) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new IndexedFaceSet(s, i);
        }
      };



      struct ElevationGrid: ComposedGeometryNode
      {
        static Ref<ElevationGrid> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ElevationGrid>(c.get(), 54);
        }

        InitializeOnly<SFFloat> creaseAngle;
        InitializeOnlySeq<MFFloat> height;
        InputOnlySeq<MFFloat> set_height;
        InitializeOnly<SFInt32> xDimension;
        InitializeOnly<SFFloat> xSpacing;
        InitializeOnly<SFInt32> zDimension;
        InitializeOnly<SFFloat> zSpacing;

        /*
         * creaseAngle
         */
        double getCreaseAngle()
        {
          return creaseAngle;
        }
        void setCreaseAngle(double v)
        {
          creaseAngle = v;
        }

        /*
         * height
         */
        std::vector<double> getHeight()
        {
          return height;
        }
        void setHeight(const std::vector<double> &v)
        {
          height = v;
        }

        /*
         * set_height
         */
        void setSet_height(const std::vector<double> &v)
        {
          set_height = v;
        }

        /*
         * xDimension
         */
        int getXDimension()
        {
          return xDimension;
        }
        void setXDimension(int v)
        {
          xDimension = v;
        }

        /*
         * xSpacing
         */
        double getXSpacing()
        {
          return xSpacing;
        }
        void setXSpacing(double v)
        {
          xSpacing = v;
        }

        /*
         * zDimension
         */
        int getZDimension()
        {
          return zDimension;
        }
        void setZDimension(int v)
        {
          zDimension = v;
        }

        /*
         * zSpacing
         */
        double getZSpacing()
        {
          return zSpacing;
        }
        void setZSpacing(double v)
        {
          zSpacing = v;
        }

      private:
        ElevationGrid(Session *s, unsigned long i): NodeBase(s, i),
          creaseAngle(this, 54),
          height(this, 182),
          set_height(this, 310),
          xDimension(this, 438),
          xSpacing(this, 566),
          zDimension(this, 694),
          zSpacing(this, 822) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ElevationGrid(s, i);
        }
      };



      struct ShapeNode: virtual ChildNode
      {
      protected:
        ShapeNode() {}
      };



      struct Shape: ShapeNode, BoundedObject
      {
        static Ref<Shape> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Shape>(c.get(), 56);
        }

        InputOutput<SFNode<AppearanceNode> > appearance;
        InputOutput<SFNode<GeometryNode> > geometry;

        /*
         * appearance
         */
        Ref<AppearanceNode> getAppearance()
        {
          return appearance;
        }
        void setAppearance(Ref<AppearanceNode> v)
        {
          appearance = v;
        }

        /*
         * geometry
         */
        Ref<GeometryNode> getGeometry()
        {
          return geometry;
        }
        void setGeometry(Ref<GeometryNode> v)
        {
          geometry = v;
        }

      private:
        Shape(Session *s, unsigned long i): NodeBase(s, i),
          appearance(this, 56),
          geometry(this, 184) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Shape(s, i);
        }
      };



      struct FontStyleNode: GeometricPropertyNode
      {
      protected:
        FontStyleNode() {}
      };



      struct FontStyle: FontStyleNode
      {
        static Ref<FontStyle> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<FontStyle>(c.get(), 58);
        }

        InitializeOnlySeq<MFString> family;
        InitializeOnly<SFBool> horizontal;
        InitializeOnlySeq<MFString> justify;
        InitializeOnly<SFString> language;
        InitializeOnly<SFBool> leftToRight;
        InitializeOnly<SFFloat> size;
        InitializeOnly<SFFloat> spacing;
        InitializeOnly<SFString> style;
        InitializeOnly<SFBool> topToBottom;

        /*
         * family
         */
        std::vector<std::string> getFamily()
        {
          return family;
        }
        void setFamily(const std::vector<std::string> &v)
        {
          family = v;
        }

        /*
         * horizontal
         */
        bool getHorizontal()
        {
          return horizontal;
        }
        void setHorizontal(bool v)
        {
          horizontal = v;
        }

        /*
         * justify
         */
        std::vector<std::string> getJustify()
        {
          return justify;
        }
        void setJustify(const std::vector<std::string> &v)
        {
          justify = v;
        }

        /*
         * language
         */
        std::string getLanguage()
        {
          return language;
        }
        void setLanguage(std::string v)
        {
          language = v;
        }

        /*
         * leftToRight
         */
        bool getLeftToRight()
        {
          return leftToRight;
        }
        void setLeftToRight(bool v)
        {
          leftToRight = v;
        }

        /*
         * size
         */
        double getSize()
        {
          return size;
        }
        void setSize(double v)
        {
          size = v;
        }

        /*
         * spacing
         */
        double getSpacing()
        {
          return spacing;
        }
        void setSpacing(double v)
        {
          spacing = v;
        }

        /*
         * style
         */
        std::string getStyle()
        {
          return style;
        }
        void setStyle(std::string v)
        {
          style = v;
        }

        /*
         * topToBottom
         */
        bool getTopToBottom()
        {
          return topToBottom;
        }
        void setTopToBottom(bool v)
        {
          topToBottom = v;
        }

      private:
        FontStyle(Session *s, unsigned long i): NodeBase(s, i),
          family(this, 58),
          horizontal(this, 186),
          justify(this, 314),
          language(this, 442),
          leftToRight(this, 570),
          size(this, 698),
          spacing(this, 826),
          style(this, 954),
          topToBottom(this, 1082) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new FontStyle(s, i);
        }
      };



      struct TextNode: GeometryNode
      {
      protected:
        TextNode() {}
      };



      struct Text: TextNode
      {
        static Ref<Text> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Text>(c.get(), 60);
        }

        InputOutputSeq<MFString> string;
        InputOutput<SFNode<FontStyleNode> > fontStyle;
        InputOutputSeq<MFFloat> length;
        InputOutput<SFFloat> maxExtent;
        InitializeOnly<SFBool> solid;

        /*
         * string
         */
        std::vector<std::string> getString()
        {
          return string;
        }
        void setString(const std::vector<std::string> &v)
        {
          string = v;
        }

        /*
         * fontStyle
         */
        Ref<FontStyleNode> getFontStyle()
        {
          return fontStyle;
        }
        void setFontStyle(Ref<FontStyleNode> v)
        {
          fontStyle = v;
        }

        /*
         * length
         */
        std::vector<double> getLength()
        {
          return length;
        }
        void setLength(const std::vector<double> &v)
        {
          length = v;
        }

        /*
         * maxExtent
         */
        double getMaxExtent()
        {
          return maxExtent;
        }
        void setMaxExtent(double v)
        {
          maxExtent = v;
        }

        /*
         * solid
         */
        bool getSolid()
        {
          return solid;
        }
        void setSolid(bool v)
        {
          solid = v;
        }

      private:
        Text(Session *s, unsigned long i): NodeBase(s, i),
          string(this, 60),
          fontStyle(this, 188),
          length(this, 316),
          maxExtent(this, 444),
          solid(this, 572) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Text(s, i);
        }
      };



      struct LightNode: virtual ChildNode
      {
        InputOutput<SFFloat> ambientIntensity;
        InputOutput<SFColor> color;
        InputOutput<SFFloat> intensity;
        InputOutput<SFBool> on;

        /*
         * ambientIntensity
         */
        double getAmbientIntensity()
        {
          return ambientIntensity;
        }
        void setAmbientIntensity(double v)
        {
          ambientIntensity = v;
        }

        /*
         * color
         */
        Vector3 getColor()
        {
          return color;
        }
        void setColor(Vector3 v)
        {
          color = v;
        }

        /*
         * intensity
         */
        double getIntensity()
        {
          return intensity;
        }
        void setIntensity(double v)
        {
          intensity = v;
        }

        /*
         * on
         */
        bool getOn()
        {
          return on;
        }
        void setOn(bool v)
        {
          on = v;
        }

      protected:
        LightNode():
          ambientIntensity(this, 61),
          color(this, 189),
          intensity(this, 317),
          on(this, 445) {}
      };



      struct DirectionalLight: LightNode
      {
        static Ref<DirectionalLight> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<DirectionalLight>(c.get(), 62);
        }

        InputOutput<SFVec3f> direction;

        /*
         * direction
         */
        Vector3 getDirection()
        {
          return direction;
        }
        void setDirection(Vector3 v)
        {
          direction = v;
        }

      private:
        DirectionalLight(Session *s, unsigned long i): NodeBase(s, i),
          direction(this, 62) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new DirectionalLight(s, i);
        }
      };



      struct PointLight: LightNode
      {
        static Ref<PointLight> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PointLight>(c.get(), 63);
        }

        InputOutput<SFVec3f> attenuation;
        InputOutput<SFVec3f> location;
        InputOutput<SFFloat> radius;

        /*
         * attenuation
         */
        Vector3 getAttenuation()
        {
          return attenuation;
        }
        void setAttenuation(Vector3 v)
        {
          attenuation = v;
        }

        /*
         * location
         */
        Vector3 getLocation()
        {
          return location;
        }
        void setLocation(Vector3 v)
        {
          location = v;
        }

        /*
         * radius
         */
        double getRadius()
        {
          return radius;
        }
        void setRadius(double v)
        {
          radius = v;
        }

      private:
        PointLight(Session *s, unsigned long i): NodeBase(s, i),
          attenuation(this, 63),
          location(this, 191),
          radius(this, 319) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PointLight(s, i);
        }
      };



      struct SpotLight: LightNode
      {
        static Ref<SpotLight> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<SpotLight>(c.get(), 64);
        }

        InputOutput<SFVec3f> attenuation;
        InputOutput<SFFloat> beamWidth;
        InputOutput<SFFloat> cutOffAngle;
        InputOutput<SFVec3f> direction;
        InputOutput<SFVec3f> location;
        InputOutput<SFFloat> radius;

        /*
         * attenuation
         */
        Vector3 getAttenuation()
        {
          return attenuation;
        }
        void setAttenuation(Vector3 v)
        {
          attenuation = v;
        }

        /*
         * beamWidth
         */
        double getBeamWidth()
        {
          return beamWidth;
        }
        void setBeamWidth(double v)
        {
          beamWidth = v;
        }

        /*
         * cutOffAngle
         */
        double getCutOffAngle()
        {
          return cutOffAngle;
        }
        void setCutOffAngle(double v)
        {
          cutOffAngle = v;
        }

        /*
         * direction
         */
        Vector3 getDirection()
        {
          return direction;
        }
        void setDirection(Vector3 v)
        {
          direction = v;
        }

        /*
         * location
         */
        Vector3 getLocation()
        {
          return location;
        }
        void setLocation(Vector3 v)
        {
          location = v;
        }

        /*
         * radius
         */
        double getRadius()
        {
          return radius;
        }
        void setRadius(double v)
        {
          radius = v;
        }

      private:
        SpotLight(Session *s, unsigned long i): NodeBase(s, i),
          attenuation(this, 64),
          beamWidth(this, 192),
          cutOffAngle(this, 320),
          direction(this, 448),
          location(this, 576),
          radius(this, 704) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new SpotLight(s, i);
        }
      };



      struct InterpolatorNode: virtual ChildNode
      {
        InputOnly<SFFloat> set_fraction;
        InputOutputSeq<MFFloat> key;

        /*
         * set_fraction
         */
        void setSet_fraction(double v)
        {
          set_fraction = v;
        }

        /*
         * key
         */
        std::vector<double> getKey()
        {
          return key;
        }
        void setKey(const std::vector<double> &v)
        {
          key = v;
        }

      protected:
        InterpolatorNode():
          set_fraction(this, 65),
          key(this, 193) {}
      };



      struct ColorInterpolator: InterpolatorNode
      {
        static Ref<ColorInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ColorInterpolator>(c.get(), 66);
        }

        InputOutputSeq<MFColor> keyValue;
        OutputOnly<SFColor> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector3> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector3> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        Vector3 getValue_changed()
        {
          return value_changed;
        }

      private:
        ColorInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 66),
          value_changed(this, 194) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ColorInterpolator(s, i);
        }
      };



      struct CoordinateInterpolator: InterpolatorNode
      {
        static Ref<CoordinateInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<CoordinateInterpolator>(c.get(), 67);
        }

        InputOutputSeq<MFVec3f> keyValue;
        OutputOnlySeq<MFVec3f> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector3> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector3> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        std::vector<Vector3> getValue_changed()
        {
          return value_changed;
        }

      private:
        CoordinateInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 67),
          value_changed(this, 195) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new CoordinateInterpolator(s, i);
        }
      };



      struct CoordinateInterpolator2D: InterpolatorNode
      {
        static Ref<CoordinateInterpolator2D> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<CoordinateInterpolator2D>(c.get(), 68);
        }

        InputOutputSeq<MFVec2f> keyValue;
        OutputOnlySeq<MFVec2f> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector2> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector2> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        std::vector<Vector2> getValue_changed()
        {
          return value_changed;
        }

      private:
        CoordinateInterpolator2D(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 68),
          value_changed(this, 196) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new CoordinateInterpolator2D(s, i);
        }
      };



      struct NormalInterpolator: InterpolatorNode
      {
        static Ref<NormalInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<NormalInterpolator>(c.get(), 69);
        }

        InputOutputSeq<MFVec3f> keyValue;
        OutputOnlySeq<MFVec3f> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector3> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector3> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        std::vector<Vector3> getValue_changed()
        {
          return value_changed;
        }

      private:
        NormalInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 69),
          value_changed(this, 197) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new NormalInterpolator(s, i);
        }
      };



      struct OrientationInterpolator: InterpolatorNode
      {
        static Ref<OrientationInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<OrientationInterpolator>(c.get(), 70);
        }

        InputOutputSeq<MFRotation> keyValue;
        OutputOnly<SFRotation> value_changed;

        /*
         * keyValue
         */
        std::vector<Rotation3> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Rotation3> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        Rotation3 getValue_changed()
        {
          return value_changed;
        }

      private:
        OrientationInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 70),
          value_changed(this, 198) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new OrientationInterpolator(s, i);
        }
      };



      struct PositionInterpolator: InterpolatorNode
      {
        static Ref<PositionInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PositionInterpolator>(c.get(), 71);
        }

        InputOutputSeq<MFVec3f> keyValue;
        OutputOnly<SFVec3f> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector3> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector3> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        Vector3 getValue_changed()
        {
          return value_changed;
        }

      private:
        PositionInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 71),
          value_changed(this, 199) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PositionInterpolator(s, i);
        }
      };



      struct PositionInterpolator2D: InterpolatorNode
      {
        static Ref<PositionInterpolator2D> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PositionInterpolator2D>(c.get(), 72);
        }

        InputOutputSeq<MFVec2f> keyValue;
        OutputOnly<SFVec2f> value_changed;

        /*
         * keyValue
         */
        std::vector<Vector2> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<Vector2> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        Vector2 getValue_changed()
        {
          return value_changed;
        }

      private:
        PositionInterpolator2D(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 72),
          value_changed(this, 200) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PositionInterpolator2D(s, i);
        }
      };



      struct ScalarInterpolator: InterpolatorNode
      {
        static Ref<ScalarInterpolator> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<ScalarInterpolator>(c.get(), 73);
        }

        InputOutputSeq<MFFloat> keyValue;
        OutputOnly<SFFloat> value_changed;

        /*
         * keyValue
         */
        std::vector<double> getKeyValue()
        {
          return keyValue;
        }
        void setKeyValue(const std::vector<double> &v)
        {
          keyValue = v;
        }

        /*
         * value_changed
         */
        double getValue_changed()
        {
          return value_changed;
        }

      private:
        ScalarInterpolator(Session *s, unsigned long i): NodeBase(s, i),
          keyValue(this, 73),
          value_changed(this, 201) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new ScalarInterpolator(s, i);
        }
      };



      struct Billboard: GroupingNode, BoundedObject
      {
        static Ref<Billboard> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Billboard>(c.get(), 74);
        }

        InputOutput<SFVec3f> axisOfRotation;

        /*
         * axisOfRotation
         */
        Vector3 getAxisOfRotation()
        {
          return axisOfRotation;
        }
        void setAxisOfRotation(Vector3 v)
        {
          axisOfRotation = v;
        }

      private:
        Billboard(Session *s, unsigned long i): NodeBase(s, i),
          axisOfRotation(this, 74) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Billboard(s, i);
        }
      };



      struct Viewpoint: BindableNode
      {
        static Ref<Viewpoint> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Viewpoint>(c.get(), 75);
        }

        InputOutput<SFBool> jump;
        InputOutput<SFVec3f> position;
        InputOutput<SFRotation> orientation;
        InputOutput<SFFloat> fieldOfView;
        InputOutput<SFVec3f> centerOfRotation;
        InitializeOnly<SFString> description;

        /*
         * jump
         */
        bool getJump()
        {
          return jump;
        }
        void setJump(bool v)
        {
          jump = v;
        }

        /*
         * position
         */
        Vector3 getPosition()
        {
          return position;
        }
        void setPosition(Vector3 v)
        {
          position = v;
        }

        /*
         * orientation
         */
        Rotation3 getOrientation()
        {
          return orientation;
        }
        void setOrientation(Rotation3 v)
        {
          orientation = v;
        }

        /*
         * fieldOfView
         */
        double getFieldOfView()
        {
          return fieldOfView;
        }
        void setFieldOfView(double v)
        {
          fieldOfView = v;
        }

        /*
         * centerOfRotation
         */
        Vector3 getCenterOfRotation()
        {
          return centerOfRotation;
        }
        void setCenterOfRotation(Vector3 v)
        {
          centerOfRotation = v;
        }

        /*
         * description
         */
        std::string getDescription()
        {
          return description;
        }
        void setDescription(std::string v)
        {
          description = v;
        }

      private:
        Viewpoint(Session *s, unsigned long i): NodeBase(s, i),
          jump(this, 75),
          position(this, 203),
          orientation(this, 331),
          fieldOfView(this, 459),
          centerOfRotation(this, 587),
          description(this, 715) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Viewpoint(s, i);
        }
      };



      struct PointingDeviceSensorNode: SensorNode
      {
        InputOutput<SFString> description;
        OutputOnly<SFBool> isOver;

        /*
         * description
         */
        std::string getDescription()
        {
          return description;
        }
        void setDescription(std::string v)
        {
          description = v;
        }

        /*
         * isOver
         */
        bool getIsOver()
        {
          return isOver;
        }

      protected:
        PointingDeviceSensorNode():
          description(this, 76),
          isOver(this, 204) {}
      };



      struct DragSensorNode: PointingDeviceSensorNode
      {
        InputOutput<SFBool> autoOffset;
        OutputOnly<SFVec3f> trackPoint_changed;

        /*
         * autoOffset
         */
        bool getAutoOffset()
        {
          return autoOffset;
        }
        void setAutoOffset(bool v)
        {
          autoOffset = v;
        }

        /*
         * trackPoint_changed
         */
        Vector3 getTrackPoint_changed()
        {
          return trackPoint_changed;
        }

      protected:
        DragSensorNode():
          autoOffset(this, 77),
          trackPoint_changed(this, 205) {}
      };



      struct PlaneSensor: DragSensorNode
      {
        static Ref<PlaneSensor> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<PlaneSensor>(c.get(), 78);
        }

        InputOutput<SFVec2f> maxPosition;
        InputOutput<SFVec2f> minPosition;
        InputOutput<SFVec3f> offset;
        OutputOnly<SFVec3f> translation_changed;

        /*
         * maxPosition
         */
        Vector2 getMaxPosition()
        {
          return maxPosition;
        }
        void setMaxPosition(Vector2 v)
        {
          maxPosition = v;
        }

        /*
         * minPosition
         */
        Vector2 getMinPosition()
        {
          return minPosition;
        }
        void setMinPosition(Vector2 v)
        {
          minPosition = v;
        }

        /*
         * offset
         */
        Vector3 getOffset()
        {
          return offset;
        }
        void setOffset(Vector3 v)
        {
          offset = v;
        }

        /*
         * translation_changed
         */
        Vector3 getTranslation_changed()
        {
          return translation_changed;
        }

      private:
        PlaneSensor(Session *s, unsigned long i): NodeBase(s, i),
          maxPosition(this, 78),
          minPosition(this, 206),
          offset(this, 334),
          translation_changed(this, 462) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new PlaneSensor(s, i);
        }
      };



      struct SphereSensor: DragSensorNode
      {
        static Ref<SphereSensor> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<SphereSensor>(c.get(), 79);
        }

        InputOutput<SFRotation> offset;
        OutputOnly<SFRotation> rotation_changed;

        /*
         * offset
         */
        Rotation3 getOffset()
        {
          return offset;
        }
        void setOffset(Rotation3 v)
        {
          offset = v;
        }

        /*
         * rotation_changed
         */
        Rotation3 getRotation_changed()
        {
          return rotation_changed;
        }

      private:
        SphereSensor(Session *s, unsigned long i): NodeBase(s, i),
          offset(this, 79),
          rotation_changed(this, 207) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new SphereSensor(s, i);
        }
      };



      struct CylinderSensor: DragSensorNode
      {
        static Ref<CylinderSensor> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<CylinderSensor>(c.get(), 80);
        }

        InputOutput<SFFloat> diskAngle;
        InputOutput<SFFloat> maxAngle;
        InputOutput<SFFloat> minAngle;
        InputOutput<SFFloat> offset;
        OutputOnly<SFRotation> rotation_changed;

        /*
         * diskAngle
         */
        double getDiskAngle()
        {
          return diskAngle;
        }
        void setDiskAngle(double v)
        {
          diskAngle = v;
        }

        /*
         * maxAngle
         */
        double getMaxAngle()
        {
          return maxAngle;
        }
        void setMaxAngle(double v)
        {
          maxAngle = v;
        }

        /*
         * minAngle
         */
        double getMinAngle()
        {
          return minAngle;
        }
        void setMinAngle(double v)
        {
          minAngle = v;
        }

        /*
         * offset
         */
        double getOffset()
        {
          return offset;
        }
        void setOffset(double v)
        {
          offset = v;
        }

        /*
         * rotation_changed
         */
        Rotation3 getRotation_changed()
        {
          return rotation_changed;
        }

      private:
        CylinderSensor(Session *s, unsigned long i): NodeBase(s, i),
          diskAngle(this, 80),
          maxAngle(this, 208),
          minAngle(this, 336),
          offset(this, 464),
          rotation_changed(this, 592) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new CylinderSensor(s, i);
        }
      };



      struct TouchSensorNode: PointingDeviceSensorNode
      {
        OutputOnly<SFTime> touchTime;

        /*
         * touchTime
         */
        Time getTouchTime()
        {
          return touchTime;
        }

      protected:
        TouchSensorNode():
          touchTime(this, 81) {}
      };



      struct TouchSensor: TouchSensorNode
      {
        static Ref<TouchSensor> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<TouchSensor>(c.get(), 82);
        }

        OutputOnly<SFVec3f> hitNormal_changed;
        OutputOnly<SFVec3f> hitPoint_changed;
        OutputOnly<SFVec2f> hitTexCoord_changed;

        /*
         * hitNormal_changed
         */
        Vector3 getHitNormal_changed()
        {
          return hitNormal_changed;
        }

        /*
         * hitPoint_changed
         */
        Vector3 getHitPoint_changed()
        {
          return hitPoint_changed;
        }

        /*
         * hitTexCoord_changed
         */
        Vector2 getHitTexCoord_changed()
        {
          return hitTexCoord_changed;
        }

      private:
        TouchSensor(Session *s, unsigned long i): NodeBase(s, i),
          hitNormal_changed(this, 82),
          hitPoint_changed(this, 210),
          hitTexCoord_changed(this, 338) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new TouchSensor(s, i);
        }
      };



      struct ScriptNode: virtual ChildNode
      {
      protected:
        ScriptNode() {}
      };



      struct Script: ScriptNode, UrlObject
      {
        static Ref<Script> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Script>(c.get(), 84);
        }

        InitializeOnly<SFBool> directOutput;
        InitializeOnly<SFBool> mustEvaluate;

        /*
         * directOutput
         */
        bool getDirectOutput()
        {
          return directOutput;
        }
        void setDirectOutput(bool v)
        {
          directOutput = v;
        }

        /*
         * mustEvaluate
         */
        bool getMustEvaluate()
        {
          return mustEvaluate;
        }
        void setMustEvaluate(bool v)
        {
          mustEvaluate = v;
        }

      private:
        Script(Session *s, unsigned long i): NodeBase(s, i),
          directOutput(this, 84),
          mustEvaluate(this, 212) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Script(s, i);
        }
      };



      struct Torus: Geometry3DNode
      {
        static Ref<Torus> create(Ref<ExecutionContext> c)
        {
          return NodeBase::create<Torus>(c.get(), 85);
        }

        InitializeOnly<SFFloat> majorRadius;
        InitializeOnly<SFFloat> minorRadius;

        /*
         * majorRadius
         */
        double getMajorRadius()
        {
          return majorRadius;
        }
        void setMajorRadius(double v)
        {
          majorRadius = v;
        }

        /*
         * minorRadius
         */
        double getMinorRadius()
        {
          return minorRadius;
        }
        void setMinorRadius(double v)
        {
          minorRadius = v;
        }

      private:
        Torus(Session *s, unsigned long i): NodeBase(s, i),
          majorRadius(this, 85),
          minorRadius(this, 213) {}

      public:
        static NodeBase *instantiate(Session *s, unsigned long i)
        {
          return new Torus(s, i);
        }
      };
    }
  }
}

#endif // ARCHON_X3D_PROXY_NODE_AUTOGEN_H

---