node.autogen.H

00001 /*
00002  * This file is part of the "Archon" framework.
00003  * (http://files3d.sourceforge.net)
00004  *
00005  * Copyright  2002 by Kristian Spangsege and Brian Kristiansen.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and
00008  * its documentation under the terms of the GNU General Public License is
00009  * hereby granted. No representations are made about the suitability of
00010  * this software for any purpose. It is provided "as is" without express
00011  * or implied warranty. See the GNU General Public License
00012  * (http://www.gnu.org/copyleft/gpl.html) for more details.
00013  *
00014  * The characters in this file are ISO8859-1 encoded.
00015  *
00016  * The documentation in this file is in "Doxygen" style
00017  * (http://www.doxygen.org).
00018  */
00019 
00020 /*
00021  * Note: This file is auto-generated, so don't edit it!
00022  */
00023 
00024 #ifndef ARCHON_X3D_PROXY_NODE_AUTOGEN_H
00025 #define ARCHON_X3D_PROXY_NODE_AUTOGEN_H
00026 
00027 #include <archon/x3d/proxy/field_type.H>
00028 #include <archon/x3d/proxy/field.H>
00029 
00030 namespace Archon
00031 {
00032   namespace X3D
00033   {
00034     namespace Proxy
00035     {
00039       struct MetadataObject: virtual NodeBase
00040       {
00041         InputOutput<SFString> name;
00042         InputOutput<SFString> reference;
00043 
00044         /*
00045          * name
00046          */
00047         std::string getName()
00048         {
00049           return name;
00050         }
00051         void setName(std::string v)
00052         {
00053           name = v;
00054         }
00055 
00056         /*
00057          * reference
00058          */
00059         std::string getReference()
00060         {
00061           return reference;
00062         }
00063         void setReference(std::string v)
00064         {
00065           reference = v;
00066         }
00067 
00068       protected:
00069         MetadataObject():
00070           name(this, 0),
00071           reference(this, 128) {}
00072       };
00073 
00074 
00075 
00079       struct Node: virtual NodeBase
00080       {
00081         InputOutput<SFNode<MetadataObject> > metadata;
00082 
00083         /*
00084          * metadata
00085          */
00086         Ref<MetadataObject> getMetadata()
00087         {
00088           return metadata;
00089         }
00090         void setMetadata(Ref<MetadataObject> v)
00091         {
00092           metadata = v;
00093         }
00094 
00095       protected:
00096         Node():
00097           metadata(this, 1) {}
00098       };
00099 
00100 
00101 
00105       struct ChildNode: virtual Node
00106       {
00107       protected:
00108         ChildNode() {}
00109       };
00110 
00111 
00112 
00116       struct SensorNode: virtual ChildNode
00117       {
00118         InputOutput<SFBool> enabled;
00119         OutputOnly<SFBool> isActive;
00120 
00121         /*
00122          * enabled
00123          */
00124         bool getEnabled()
00125         {
00126           return enabled;
00127         }
00128         void setEnabled(bool v)
00129         {
00130           enabled = v;
00131         }
00132 
00133         /*
00134          * isActive
00135          */
00136         bool getIsActive()
00137         {
00138           return isActive;
00139         }
00140 
00141       protected:
00142         SensorNode():
00143           enabled(this, 3),
00144           isActive(this, 131) {}
00145       };
00146 
00147 
00148 
00152       struct MetadataDouble: virtual Node, MetadataObject
00153       {
00154         static Ref<MetadataDouble> create(Ref<ExecutionContext> c)
00155         {
00156           return NodeBase::create<MetadataDouble>(c.get(), 4);
00157         }
00158 
00159         InputOutputSeq<MFDouble> value;
00160 
00161         /*
00162          * value
00163          */
00164         std::vector<double> getValue()
00165         {
00166           return value;
00167         }
00168         void setValue(const std::vector<double> &v)
00169         {
00170           value = v;
00171         }
00172 
00173       private:
00174         MetadataDouble(Session *s, unsigned long i): NodeBase(s, i),
00175           value(this, 4) {}
00176 
00177       public:
00178         static NodeBase *instantiate(Session *s, unsigned long i)
00179         {
00180           return new MetadataDouble(s, i);
00181         }
00182       };
00183 
00184 
00185 
00189       struct MetadataFloat: virtual Node, MetadataObject
00190       {
00191         static Ref<MetadataFloat> create(Ref<ExecutionContext> c)
00192         {
00193           return NodeBase::create<MetadataFloat>(c.get(), 5);
00194         }
00195 
00196         InputOutputSeq<MFFloat> value;
00197 
00198         /*
00199          * value
00200          */
00201         std::vector<double> getValue()
00202         {
00203           return value;
00204         }
00205         void setValue(const std::vector<double> &v)
00206         {
00207           value = v;
00208         }
00209 
00210       private:
00211         MetadataFloat(Session *s, unsigned long i): NodeBase(s, i),
00212           value(this, 5) {}
00213 
00214       public:
00215         static NodeBase *instantiate(Session *s, unsigned long i)
00216         {
00217           return new MetadataFloat(s, i);
00218         }
00219       };
00220 
00221 
00222 
00226       struct MetadataInteger: virtual Node, MetadataObject
00227       {
00228         static Ref<MetadataInteger> create(Ref<ExecutionContext> c)
00229         {
00230           return NodeBase::create<MetadataInteger>(c.get(), 6);
00231         }
00232 
00233         InputOutputSeq<MFInt32> value;
00234 
00235         /*
00236          * value
00237          */
00238         std::vector<int> getValue()
00239         {
00240           return value;
00241         }
00242         void setValue(const std::vector<int> &v)
00243         {
00244           value = v;
00245         }
00246 
00247       private:
00248         MetadataInteger(Session *s, unsigned long i): NodeBase(s, i),
00249           value(this, 6) {}
00250 
00251       public:
00252         static NodeBase *instantiate(Session *s, unsigned long i)
00253         {
00254           return new MetadataInteger(s, i);
00255         }
00256       };
00257 
00258 
00259 
00263       struct MetadataSet: virtual Node, MetadataObject
00264       {
00265         static Ref<MetadataSet> create(Ref<ExecutionContext> c)
00266         {
00267           return NodeBase::create<MetadataSet>(c.get(), 7);
00268         }
00269 
00270         InputOutputSeq<MFNode<MetadataObject> > value;
00271 
00272         /*
00273          * value
00274          */
00275         std::vector<Ref<MetadataObject> > getValue()
00276         {
00277           return value;
00278         }
00279         void setValue(const std::vector<Ref<MetadataObject> > &v)
00280         {
00281           value = v;
00282         }
00283 
00284       private:
00285         MetadataSet(Session *s, unsigned long i): NodeBase(s, i),
00286           value(this, 7) {}
00287 
00288       public:
00289         static NodeBase *instantiate(Session *s, unsigned long i)
00290         {
00291           return new MetadataSet(s, i);
00292         }
00293       };
00294 
00295 
00296 
00300       struct MetadataString: virtual Node, MetadataObject
00301       {
00302         static Ref<MetadataString> create(Ref<ExecutionContext> c)
00303         {
00304           return NodeBase::create<MetadataString>(c.get(), 8);
00305         }
00306 
00307         InputOutputSeq<MFString> value;
00308 
00309         /*
00310          * value
00311          */
00312         std::vector<std::string> getValue()
00313         {
00314           return value;
00315         }
00316         void setValue(const std::vector<std::string> &v)
00317         {
00318           value = v;
00319         }
00320 
00321       private:
00322         MetadataString(Session *s, unsigned long i): NodeBase(s, i),
00323           value(this, 8) {}
00324 
00325       public:
00326         static NodeBase *instantiate(Session *s, unsigned long i)
00327         {
00328           return new MetadataString(s, i);
00329         }
00330       };
00331 
00332 
00333 
00337       struct TimeDependentNode: virtual ChildNode
00338       {
00339         OutputOnly<SFBool> isPaused;
00340         OutputOnly<SFTime> elapsedTime;
00341         InputOutput<SFBool> loop;
00342         InputOutput<SFFloat> numLoops;
00343         InputOutput<SFTime> startTime;
00344         InputOutput<SFTime> stopTime;
00345         InputOutput<SFTime> pauseTime;
00346         InputOutput<SFTime> resumeTime;
00347 
00348         /*
00349          * isPaused
00350          */
00351         bool getIsPaused()
00352         {
00353           return isPaused;
00354         }
00355 
00356         /*
00357          * elapsedTime
00358          */
00359         Time getElapsedTime()
00360         {
00361           return elapsedTime;
00362         }
00363 
00364         /*
00365          * loop
00366          */
00367         bool getLoop()
00368         {
00369           return loop;
00370         }
00371         void setLoop(bool v)
00372         {
00373           loop = v;
00374         }
00375 
00376         /*
00377          * numLoops
00378          */
00379         double getNumLoops()
00380         {
00381           return numLoops;
00382         }
00383         void setNumLoops(double v)
00384         {
00385           numLoops = v;
00386         }
00387 
00388         /*
00389          * startTime
00390          */
00391         Time getStartTime()
00392         {
00393           return startTime;
00394         }
00395         void setStartTime(Time v)
00396         {
00397           startTime = v;
00398         }
00399 
00400         /*
00401          * stopTime
00402          */
00403         Time getStopTime()
00404         {
00405           return stopTime;
00406         }
00407         void setStopTime(Time v)
00408         {
00409           stopTime = v;
00410         }
00411 
00412         /*
00413          * pauseTime
00414          */
00415         Time getPauseTime()
00416         {
00417           return pauseTime;
00418         }
00419         void setPauseTime(Time v)
00420         {
00421           pauseTime = v;
00422         }
00423 
00424         /*
00425          * resumeTime
00426          */
00427         Time getResumeTime()
00428         {
00429           return resumeTime;
00430         }
00431         void setResumeTime(Time v)
00432         {
00433           resumeTime = v;
00434         }
00435 
00436       protected:
00437         TimeDependentNode():
00438           isPaused(this, 9),
00439           elapsedTime(this, 137),
00440           loop(this, 265),
00441           numLoops(this, 393),
00442           startTime(this, 521),
00443           stopTime(this, 649),
00444           pauseTime(this, 777),
00445           resumeTime(this, 905) {}
00446       };
00447 
00448 
00449 
00453       struct TimeSensor: TimeDependentNode, SensorNode
00454       {
00455         static Ref<TimeSensor> create(Ref<ExecutionContext> c)
00456         {
00457           return NodeBase::create<TimeSensor>(c.get(), 10);
00458         }
00459 
00460         InputOutput<SFTime> cycleInterval;
00461         OutputOnly<SFTime> cycleTime;
00462         OutputOnly<SFFloat> fraction_changed;
00463         OutputOnly<SFTime> time;
00464 
00465         /*
00466          * cycleInterval
00467          */
00468         Time getCycleInterval()
00469         {
00470           return cycleInterval;
00471         }
00472         void setCycleInterval(Time v)
00473         {
00474           cycleInterval = v;
00475         }
00476 
00477         /*
00478          * cycleTime
00479          */
00480         Time getCycleTime()
00481         {
00482           return cycleTime;
00483         }
00484 
00485         /*
00486          * fraction_changed
00487          */
00488         double getFraction_changed()
00489         {
00490           return fraction_changed;
00491         }
00492 
00493         /*
00494          * time
00495          */
00496         Time getTime()
00497         {
00498           return time;
00499         }
00500 
00501       private:
00502         TimeSensor(Session *s, unsigned long i): NodeBase(s, i),
00503           cycleInterval(this, 10),
00504           cycleTime(this, 138),
00505           fraction_changed(this, 266),
00506           time(this, 394) {}
00507 
00508       public:
00509         static NodeBase *instantiate(Session *s, unsigned long i)
00510         {
00511           return new TimeSensor(s, i);
00512         }
00513       };
00514 
00515 
00516 
00520       struct UrlObject: virtual NodeBase
00521       {
00522         InputOutputSeq<MFString> url;
00523 
00524         /*
00525          * url
00526          */
00527         std::vector<std::string> getUrl()
00528         {
00529           return url;
00530         }
00531         void setUrl(const std::vector<std::string> &v)
00532         {
00533           url = v;
00534         }
00535 
00536       protected:
00537         UrlObject():
00538           url(this, 11) {}
00539       };
00540 
00541 
00542 
00546       struct SubSceneNode: virtual ChildNode
00547       {
00548       protected:
00549         SubSceneNode() {}
00550       };
00551 
00552 
00553 
00557       struct Inline: SubSceneNode, UrlObject
00558       {
00559         static Ref<Inline> create(Ref<ExecutionContext> c)
00560         {
00561           return NodeBase::create<Inline>(c.get(), 13);
00562         }
00563 
00564         InputOutput<SFBool> load;
00565 
00566         /*
00567          * load
00568          */
00569         bool getLoad()
00570         {
00571           return load;
00572         }
00573         void setLoad(bool v)
00574         {
00575           load = v;
00576         }
00577 
00578       private:
00579         Inline(Session *s, unsigned long i): NodeBase(s, i),
00580           load(this, 13) {}
00581 
00582       public:
00583         static NodeBase *instantiate(Session *s, unsigned long i)
00584         {
00585           return new Inline(s, i);
00586         }
00587       };
00588 
00589 
00590 
00594       struct ApplicationLink: SubSceneNode
00595       {
00596         static Ref<ApplicationLink> create(Ref<ExecutionContext> c)
00597         {
00598           return NodeBase::create<ApplicationLink>(c.get(), 14);
00599         }
00600 
00601       private:
00602         ApplicationLink(Session *s, unsigned long i): NodeBase(s, i) {}
00603 
00604       public:
00605         static NodeBase *instantiate(Session *s, unsigned long i)
00606         {
00607           return new ApplicationLink(s, i);
00608         }
00609       };
00610 
00611 
00612 
00616       struct BoundedObject: virtual NodeBase
00617       {
00618         InitializeOnly<SFVec3f> bboxCenter;
00619         InitializeOnly<SFVec3f> bboxSize;
00620 
00621         /*
00622          * bboxCenter
00623          */
00624         Vector3 getBboxCenter()
00625         {
00626           return bboxCenter;
00627         }
00628         void setBboxCenter(Vector3 v)
00629         {
00630           bboxCenter = v;
00631         }
00632 
00633         /*
00634          * bboxSize
00635          */
00636         Vector3 getBboxSize()
00637         {
00638           return bboxSize;
00639         }
00640         void setBboxSize(Vector3 v)
00641         {
00642           bboxSize = v;
00643         }
00644 
00645       protected:
00646         BoundedObject():
00647           bboxCenter(this, 15),
00648           bboxSize(this, 143) {}
00649       };
00650 
00651 
00652 
00656       struct GroupingNode: virtual ChildNode
00657       {
00658         InputOnlySeq<MFNode<ChildNode> > addChildren;
00659         InputOnlySeq<MFNode<ChildNode> > removeChildren;
00660         InputOutputSeq<MFNode<ChildNode> > children;
00661 
00662         /*
00663          * addChildren
00664          */
00665         void setAddChildren(const std::vector<Ref<ChildNode> > &v)
00666         {
00667           addChildren = v;
00668         }
00669 
00670         /*
00671          * removeChildren
00672          */
00673         void setRemoveChildren(const std::vector<Ref<ChildNode> > &v)
00674         {
00675           removeChildren = v;
00676         }
00677 
00678         /*
00679          * children
00680          */
00681         std::vector<Ref<ChildNode> > getChildren()
00682         {
00683           return children;
00684         }
00685         void setChildren(const std::vector<Ref<ChildNode> > &v)
00686         {
00687           children = v;
00688         }
00689 
00690       protected:
00691         GroupingNode():
00692           addChildren(this, 16),
00693           removeChildren(this, 144),
00694           children(this, 272) {}
00695       };
00696 
00697 
00698 
00702       struct Group: GroupingNode, BoundedObject
00703       {
00704         static Ref<Group> create(Ref<ExecutionContext> c)
00705         {
00706           return NodeBase::create<Group>(c.get(), 17);
00707         }
00708 
00709       private:
00710         Group(Session *s, unsigned long i): NodeBase(s, i) {}
00711 
00712       public:
00713         static NodeBase *instantiate(Session *s, unsigned long i)
00714         {
00715           return new Group(s, i);
00716         }
00717       };
00718 
00719 
00720 
00724       struct Switch: GroupingNode, BoundedObject
00725       {
00726         static Ref<Switch> create(Ref<ExecutionContext> c)
00727         {
00728           return NodeBase::create<Switch>(c.get(), 18);
00729         }
00730 
00731         InputOutput<SFInt32> whichChoice;
00732 
00733         /*
00734          * whichChoice
00735          */
00736         int getWhichChoice()
00737         {
00738           return whichChoice;
00739         }
00740         void setWhichChoice(int v)
00741         {
00742           whichChoice = v;
00743         }
00744 
00745       private:
00746         Switch(Session *s, unsigned long i): NodeBase(s, i),
00747           whichChoice(this, 18) {}
00748 
00749       public:
00750         static NodeBase *instantiate(Session *s, unsigned long i)
00751         {
00752           return new Switch(s, i);
00753         }
00754       };
00755 
00756 
00757 
00761       struct Transform: GroupingNode, BoundedObject
00762       {
00763         static Ref<Transform> create(Ref<ExecutionContext> c)
00764         {
00765           return NodeBase::create<Transform>(c.get(), 19);
00766         }
00767 
00768         InputOutput<SFVec3f> center;
00769         InputOutput<SFRotation> rotation;
00770         InputOutput<SFVec3f> scale;
00771         InputOutput<SFRotation> scaleOrientation;
00772         InputOutput<SFVec3f> translation;
00773 
00774         /*
00775          * center
00776          */
00777         Vector3 getCenter()
00778         {
00779           return center;
00780         }
00781         void setCenter(Vector3 v)
00782         {
00783           center = v;
00784         }
00785 
00786         /*
00787          * rotation
00788          */
00789         Rotation3 getRotation()
00790         {
00791           return rotation;
00792         }
00793         void setRotation(Rotation3 v)
00794         {
00795           rotation = v;
00796         }
00797 
00798         /*
00799          * scale
00800          */
00801         Vector3 getScale()
00802         {
00803           return scale;
00804         }
00805         void setScale(Vector3 v)
00806         {
00807           scale = v;
00808         }
00809 
00810         /*
00811          * scaleOrientation
00812          */
00813         Rotation3 getScaleOrientation()
00814         {
00815           return scaleOrientation;
00816         }
00817         void setScaleOrientation(Rotation3 v)
00818         {
00819           scaleOrientation = v;
00820         }
00821 
00822         /*
00823          * translation
00824          */
00825         Vector3 getTranslation()
00826         {
00827           return translation;
00828         }
00829         void setTranslation(Vector3 v)
00830         {
00831           translation = v;
00832         }
00833 
00834       private:
00835         Transform(Session *s, unsigned long i): NodeBase(s, i),
00836           center(this, 19),
00837           rotation(this, 147),
00838           scale(this, 275),
00839           scaleOrientation(this, 403),
00840           translation(this, 531) {}
00841 
00842       public:
00843         static NodeBase *instantiate(Session *s, unsigned long i)
00844         {
00845           return new Transform(s, i);
00846         }
00847       };
00848 
00849 
00850 
00854       struct GeometricPropertyNode: virtual Node
00855       {
00856       protected:
00857         GeometricPropertyNode() {}
00858       };
00859 
00860 
00861 
00865       struct ColorNode: GeometricPropertyNode
00866       {
00867       protected:
00868         ColorNode() {}
00869       };
00870 
00871 
00872 
00876       struct CoordinateNode: GeometricPropertyNode
00877       {
00878       protected:
00879         CoordinateNode() {}
00880       };
00881 
00882 
00883 
00887       struct NormalNode: GeometricPropertyNode
00888       {
00889       protected:
00890         NormalNode() {}
00891       };
00892 
00893 
00894 
00898       struct Color: ColorNode
00899       {
00900         static Ref<Color> create(Ref<ExecutionContext> c)
00901         {
00902           return NodeBase::create<Color>(c.get(), 24);
00903         }
00904 
00905         InputOutputSeq<MFColor> color;
00906 
00907         /*
00908          * color
00909          */
00910         std::vector<Vector3> getColor()
00911         {
00912           return color;
00913         }
00914         void setColor(const std::vector<Vector3> &v)
00915         {
00916           color = v;
00917         }
00918 
00919       private:
00920         Color(Session *s, unsigned long i): NodeBase(s, i),
00921           color(this, 24) {}
00922 
00923       public:
00924         static NodeBase *instantiate(Session *s, unsigned long i)
00925         {
00926           return new Color(s, i);
00927         }
00928       };
00929 
00930 
00931 
00935       struct ColorRGBA: ColorNode
00936       {
00937         static Ref<ColorRGBA> create(Ref<ExecutionContext> c)
00938         {
00939           return NodeBase::create<ColorRGBA>(c.get(), 25);
00940         }
00941 
00942         InputOutputSeq<MFColorRGBA> color;
00943 
00944         /*
00945          * color
00946          */
00947         std::vector<Vector4> getColor()
00948         {
00949           return color;
00950         }
00951         void setColor(const std::vector<Vector4> &v)
00952         {
00953           color = v;
00954         }
00955 
00956       private:
00957         ColorRGBA(Session *s, unsigned long i): NodeBase(s, i),
00958           color(this, 25) {}
00959 
00960       public:
00961         static NodeBase *instantiate(Session *s, unsigned long i)
00962         {
00963           return new ColorRGBA(s, i);
00964         }
00965       };
00966 
00967 
00968 
00972       struct Coordinate: CoordinateNode
00973       {
00974         static Ref<Coordinate> create(Ref<ExecutionContext> c)
00975         {
00976           return NodeBase::create<Coordinate>(c.get(), 26);
00977         }
00978 
00979         InputOutputSeq<MFVec3f> point;
00980 
00981         /*
00982          * point
00983          */
00984         std::vector<Vector3> getPoint()
00985         {
00986           return point;
00987         }
00988         void setPoint(const std::vector<Vector3> &v)
00989         {
00990           point = v;
00991         }
00992 
00993       private:
00994         Coordinate(Session *s, unsigned long i): NodeBase(s, i),
00995           point(this, 26) {}
00996 
00997       public:
00998         static NodeBase *instantiate(Session *s, unsigned long i)
00999         {
01000           return new Coordinate(s, i);
01001         }
01002       };
01003 
01004 
01005 
01009       struct Normal: NormalNode
01010       {
01011         static Ref<Normal> create(Ref<ExecutionContext> c)
01012         {
01013           return NodeBase::create<Normal>(c.get(), 27);
01014         }
01015 
01016         InputOutputSeq<MFVec3f> vector;
01017 
01018         /*
01019          * vector
01020          */
01021         std::vector<Vector3> getVector()
01022         {
01023           return vector;
01024         }
01025         void setVector(const std::vector<Vector3> &v)
01026         {
01027           vector = v;
01028         }
01029 
01030       private:
01031         Normal(Session *s, unsigned long i): NodeBase(s, i),
01032           vector(this, 27) {}
01033 
01034       public:
01035         static NodeBase *instantiate(Session *s, unsigned long i)
01036         {
01037           return new Normal(s, i);
01038         }
01039       };
01040 
01041 
01042 
01046       struct TextureCoordinateNode: GeometricPropertyNode
01047       {
01048       protected:
01049         TextureCoordinateNode() {}
01050       };
01051 
01052 
01053 
01057       struct TextureCoordinate: TextureCoordinateNode
01058       {
01059         static Ref<TextureCoordinate> create(Ref<ExecutionContext> c)
01060         {
01061           return NodeBase::create<TextureCoordinate>(c.get(), 29);
01062         }
01063 
01064         InputOutputSeq<MFVec2f> point;
01065 
01066         /*
01067          * point
01068          */
01069         std::vector<Vector2> getPoint()
01070         {
01071           return point;
01072         }
01073         void setPoint(const std::vector<Vector2> &v)
01074         {
01075           point = v;
01076         }
01077 
01078       private:
01079         TextureCoordinate(Session *s, unsigned long i): NodeBase(s, i),
01080           point(this, 29) {}
01081 
01082       public:
01083         static NodeBase *instantiate(Session *s, unsigned long i)
01084         {
01085           return new TextureCoordinate(s, i);
01086         }
01087       };
01088 
01089 
01090 
01094       struct AppearanceChildNode: virtual Node
01095       {
01096       protected:
01097         AppearanceChildNode() {}
01098       };
01099 
01100 
01101 
01105       struct TextureTransformNode: AppearanceChildNode
01106       {
01107       protected:
01108         TextureTransformNode() {}
01109       };
01110 
01111 
01112 
01116       struct TextureTransform: TextureTransformNode
01117       {
01118         static Ref<TextureTransform> create(Ref<ExecutionContext> c)
01119         {
01120           return NodeBase::create<TextureTransform>(c.get(), 32);
01121         }
01122 
01123         InputOutput<SFVec2f> center;
01124         InputOutput<SFFloat> rotation;
01125         InputOutput<SFVec2f> scale;
01126         InputOutput<SFVec2f> translation;
01127 
01128         /*
01129          * center
01130          */
01131         Vector2 getCenter()
01132         {
01133           return center;
01134         }
01135         void setCenter(Vector2 v)
01136         {
01137           center = v;
01138         }
01139 
01140         /*
01141          * rotation
01142          */
01143         double getRotation()
01144         {
01145           return rotation;
01146         }
01147         void setRotation(double v)
01148         {
01149           rotation = v;
01150         }
01151 
01152         /*
01153          * scale
01154          */
01155         Vector2 getScale()
01156         {
01157           return scale;
01158         }
01159         void setScale(Vector2 v)
01160         {
01161           scale = v;
01162         }
01163 
01164         /*
01165          * translation
01166          */
01167         Vector2 getTranslation()
01168         {
01169           return translation;
01170         }
01171         void setTranslation(Vector2 v)
01172         {
01173           translation = v;
01174         }
01175 
01176       private:
01177         TextureTransform(Session *s, unsigned long i): NodeBase(s, i),
01178           center(this, 32),
01179           rotation(this, 160),
01180           scale(this, 288),
01181           translation(this, 416) {}
01182 
01183       public:
01184         static NodeBase *instantiate(Session *s, unsigned long i)
01185         {
01186           return new TextureTransform(s, i);
01187         }
01188       };
01189 
01190 
01191 
01195       struct TextureNode: AppearanceChildNode
01196       {
01197       protected:
01198         TextureNode() {}
01199       };
01200 
01201 
01202 
01206       struct Texture2DNode: TextureNode
01207       {
01208         InitializeOnly<SFBool> repeatS;
01209         InitializeOnly<SFBool> repeatT;
01210 
01211         /*
01212          * repeatS
01213          */
01214         bool getRepeatS()
01215         {
01216           return repeatS;
01217         }
01218         void setRepeatS(bool v)
01219         {
01220           repeatS = v;
01221         }
01222 
01223         /*
01224          * repeatT
01225          */
01226         bool getRepeatT()
01227         {
01228           return repeatT;
01229         }
01230         void setRepeatT(bool v)
01231         {
01232           repeatT = v;
01233         }
01234 
01235       protected:
01236         Texture2DNode():
01237           repeatS(this, 34),
01238           repeatT(this, 162) {}
01239       };
01240 
01241 
01242 
01246       struct ImageTexture: Texture2DNode, UrlObject
01247       {
01248         static Ref<ImageTexture> create(Ref<ExecutionContext> c)
01249         {
01250           return NodeBase::create<ImageTexture>(c.get(), 35);
01251         }
01252 
01253       private:
01254         ImageTexture(Session *s, unsigned long i): NodeBase(s, i) {}
01255 
01256       public:
01257         static NodeBase *instantiate(Session *s, unsigned long i)
01258         {
01259           return new ImageTexture(s, i);
01260         }
01261       };
01262 
01263 
01264 
01268       struct PixelTexture: Texture2DNode
01269       {
01270         static Ref<PixelTexture> create(Ref<ExecutionContext> c)
01271         {
01272           return NodeBase::create<PixelTexture>(c.get(), 36);
01273         }
01274 
01275         InputOutput<SFImage> image;
01276 
01277         /*
01278          * image
01279          */
01280         Image getImage()
01281         {
01282           return image;
01283         }
01284         void setImage(const Image &v)
01285         {
01286           image = v;
01287         }
01288 
01289       private:
01290         PixelTexture(Session *s, unsigned long i): NodeBase(s, i),
01291           image(this, 36) {}
01292 
01293       public:
01294         static NodeBase *instantiate(Session *s, unsigned long i)
01295         {
01296           return new PixelTexture(s, i);
01297         }
01298       };
01299 
01300 
01301 
01305       struct MaterialNode: AppearanceChildNode
01306       {
01307       protected:
01308         MaterialNode() {}
01309       };
01310 
01311 
01312 
01316       struct Material: MaterialNode
01317       {
01318         static Ref<Material> create(Ref<ExecutionContext> c)
01319         {
01320           return NodeBase::create<Material>(c.get(), 38);
01321         }
01322 
01323         InputOutput<SFFloat> ambientIntensity;
01324         InputOutput<SFColor> diffuseColor;
01325         InputOutput<SFColor> emissiveColor;
01326         InputOutput<SFFloat> shininess;
01327         InputOutput<SFColor> specularColor;
01328         InputOutput<SFFloat> transparency;
01329         InputOutput<SFFloat> refractiveIndex;
01330 
01331         /*
01332          * ambientIntensity
01333          */
01334         double getAmbientIntensity()
01335         {
01336           return ambientIntensity;
01337         }
01338         void setAmbientIntensity(double v)
01339         {
01340           ambientIntensity = v;
01341         }
01342 
01343         /*
01344          * diffuseColor
01345          */
01346         Vector3 getDiffuseColor()
01347         {
01348           return diffuseColor;
01349         }
01350         void setDiffuseColor(Vector3 v)
01351         {
01352           diffuseColor = v;
01353         }
01354 
01355         /*
01356          * emissiveColor
01357          */
01358         Vector3 getEmissiveColor()
01359         {
01360           return emissiveColor;
01361         }
01362         void setEmissiveColor(Vector3 v)
01363         {
01364           emissiveColor = v;
01365         }
01366 
01367         /*
01368          * shininess
01369          */
01370         double getShininess()
01371         {
01372           return shininess;
01373         }
01374         void setShininess(double v)
01375         {
01376           shininess = v;
01377         }
01378 
01379         /*
01380          * specularColor
01381          */
01382         Vector3 getSpecularColor()
01383         {
01384           return specularColor;
01385         }
01386         void setSpecularColor(Vector3 v)
01387         {
01388           specularColor = v;
01389         }
01390 
01391         /*
01392          * transparency
01393          */
01394         double getTransparency()
01395         {
01396           return transparency;
01397         }
01398         void setTransparency(double v)
01399         {
01400           transparency = v;
01401         }
01402 
01403         /*
01404          * refractiveIndex
01405          */
01406         double getRefractiveIndex()
01407         {
01408           return refractiveIndex;
01409         }
01410         void setRefractiveIndex(double v)
01411         {
01412           refractiveIndex = v;
01413         }
01414 
01415       private:
01416         Material(Session *s, unsigned long i): NodeBase(s, i),
01417           ambientIntensity(this, 38),
01418           diffuseColor(this, 166),
01419           emissiveColor(this, 294),
01420           shininess(this, 422),
01421           specularColor(this, 550),
01422           transparency(this, 678),
01423           refractiveIndex(this, 806) {}
01424 
01425       public:
01426         static NodeBase *instantiate(Session *s, unsigned long i)
01427         {
01428           return new Material(s, i);
01429         }
01430       };
01431 
01432 
01433 
01437       struct AppearanceNode: virtual Node
01438       {
01439       protected:
01440         AppearanceNode() {}
01441       };
01442 
01443 
01444 
01448       struct Appearance: AppearanceNode
01449       {
01450         static Ref<Appearance> create(Ref<ExecutionContext> c)
01451         {
01452           return NodeBase::create<Appearance>(c.get(), 40);
01453         }
01454 
01455         InputOutput<SFNode<MaterialNode> > material;
01456         InputOutput<SFNode<TextureNode> > texture;
01457         InputOutput<SFNode<TextureTransformNode> > textureTransform;
01458 
01459         /*
01460          * material
01461          */
01462         Ref<MaterialNode> getMaterial()
01463         {
01464           return material;
01465         }
01466         void setMaterial(Ref<MaterialNode> v)
01467         {
01468           material = v;
01469         }
01470 
01471         /*
01472          * texture
01473          */
01474         Ref<TextureNode> getTexture()
01475         {
01476           return texture;
01477         }
01478         void setTexture(Ref<TextureNode> v)
01479         {
01480           texture = v;
01481         }
01482 
01483         /*
01484          * textureTransform
01485          */
01486         Ref<TextureTransformNode> getTextureTransform()
01487         {
01488           return textureTransform;
01489         }
01490         void setTextureTransform(Ref<TextureTransformNode> v)
01491         {
01492           textureTransform = v;
01493         }
01494 
01495       private:
01496         Appearance(Session *s, unsigned long i): NodeBase(s, i),
01497           material(this, 40),
01498           texture(this, 168),
01499           textureTransform(this, 296) {}
01500 
01501       public:
01502         static NodeBase *instantiate(Session *s, unsigned long i)
01503         {
01504           return new Appearance(s, i);
01505         }
01506       };
01507 
01508 
01509 
01513       struct BindableNode: virtual ChildNode
01514       {
01515         InputOnly<SFBool> set_bind;
01516         OutputOnly<SFBool> isBound;
01517         OutputOnly<SFTime> bindTime;
01518 
01519         /*
01520          * set_bind
01521          */
01522         void setSet_bind(bool v)
01523         {
01524           set_bind = v;
01525         }
01526 
01527         /*
01528          * isBound
01529          */
01530         bool getIsBound()
01531         {
01532           return isBound;
01533         }
01534 
01535         /*
01536          * bindTime
01537          */
01538         Time getBindTime()
01539         {
01540           return bindTime;
01541         }
01542 
01543       protected:
01544         BindableNode():
01545           set_bind(this, 41),
01546           isBound(this, 169),
01547           bindTime(this, 297) {}
01548       };
01549 
01550 
01551 
01555       struct Fog: BindableNode
01556       {
01557         static Ref<Fog> create(Ref<ExecutionContext> c)
01558         {
01559           return NodeBase::create<Fog>(c.get(), 42);
01560         }
01561 
01562         InputOutput<SFColor> color;
01563         InputOutput<SFString> fogType;
01564         InputOutput<SFFloat> visibilityRange;
01565 
01566         /*
01567          * color
01568          */
01569         Vector3 getColor()
01570         {
01571           return color;
01572         }
01573         void setColor(Vector3 v)
01574         {
01575           color = v;
01576         }
01577 
01578         /*
01579          * fogType
01580          */
01581         std::string getFogType()
01582         {
01583           return fogType;
01584         }
01585         void setFogType(std::string v)
01586         {
01587           fogType = v;
01588         }
01589 
01590         /*
01591          * visibilityRange
01592          */
01593         double getVisibilityRange()
01594         {
01595           return visibilityRange;
01596         }
01597         void setVisibilityRange(double v)
01598         {
01599           visibilityRange = v;
01600         }
01601 
01602       private:
01603         Fog(Session *s, unsigned long i): NodeBase(s, i),
01604           color(this, 42),
01605           fogType(this, 170),
01606           visibilityRange(this, 298) {}
01607 
01608       public:
01609         static NodeBase *instantiate(Session *s, unsigned long i)
01610         {
01611           return new Fog(s, i);
01612         }
01613       };
01614 
01615 
01616 
01620       struct Background: BindableNode
01621       {
01622         static Ref<Background> create(Ref<ExecutionContext> c)
01623         {
01624           return NodeBase::create<Background>(c.get(), 43);
01625         }
01626 
01627         InputOutputSeq<MFFloat> groundAngle;
01628         InputOutputSeq<MFVec3f> groundColor;
01629         InputOutputSeq<MFString> backUrl;
01630         InputOutputSeq<MFString> bottomUrl;
01631         InputOutputSeq<MFString> frontUrl;
01632         InputOutputSeq<MFString> leftUrl;
01633         InputOutputSeq<MFString> rightUrl;
01634         InputOutputSeq<MFString> topUrl;
01635         InputOutputSeq<MFFloat> skyAngle;
01636         InputOutputSeq<MFVec3f> skyColor;
01637 
01638         /*
01639          * groundAngle
01640          */
01641         std::vector<double> getGroundAngle()
01642         {
01643           return groundAngle;
01644         }
01645         void setGroundAngle(const std::vector<double> &v)
01646         {
01647           groundAngle = v;
01648         }
01649 
01650         /*
01651          * groundColor
01652          */
01653         std::vector<Vector3> getGroundColor()
01654         {
01655           return groundColor;
01656         }
01657         void setGroundColor(const std::vector<Vector3> &v)
01658         {
01659           groundColor = v;
01660         }
01661 
01662         /*
01663          * backUrl
01664          */
01665         std::vector<std::string> getBackUrl()
01666         {
01667           return backUrl;
01668         }
01669         void setBackUrl(const std::vector<std::string> &v)
01670         {
01671           backUrl = v;
01672         }
01673 
01674         /*
01675          * bottomUrl
01676          */
01677         std::vector<std::string> getBottomUrl()
01678         {
01679           return bottomUrl;
01680         }
01681         void setBottomUrl(const std::vector<std::string> &v)
01682         {
01683           bottomUrl = v;
01684         }
01685 
01686         /*
01687          * frontUrl
01688          */
01689         std::vector<std::string> getFrontUrl()
01690         {
01691           return frontUrl;
01692         }
01693         void setFrontUrl(const std::vector<std::string> &v)
01694         {
01695           frontUrl = v;
01696         }
01697 
01698         /*
01699          * leftUrl
01700          */
01701         std::vector<std::string> getLeftUrl()
01702         {
01703           return leftUrl;
01704         }
01705         void setLeftUrl(const std::vector<std::string> &v)
01706         {
01707           leftUrl = v;
01708         }
01709 
01710         /*
01711          * rightUrl
01712          */
01713         std::vector<std::string> getRightUrl()
01714         {
01715           return rightUrl;
01716         }
01717         void setRightUrl(const std::vector<std::string> &v)
01718         {
01719           rightUrl = v;
01720         }
01721 
01722         /*
01723          * topUrl
01724          */
01725         std::vector<std::string> getTopUrl()
01726         {
01727           return topUrl;
01728         }
01729         void setTopUrl(const std::vector<std::string> &v)
01730         {
01731           topUrl = v;
01732         }
01733 
01734         /*
01735          * skyAngle
01736          */
01737         std::vector<double> getSkyAngle()
01738         {
01739           return skyAngle;
01740         }
01741         void setSkyAngle(const std::vector<double> &v)
01742         {
01743           skyAngle = v;
01744         }
01745 
01746         /*
01747          * skyColor
01748          */
01749         std::vector<Vector3> getSkyColor()
01750         {
01751           return skyColor;
01752         }
01753         void setSkyColor(const std::vector<Vector3> &v)
01754         {
01755           skyColor = v;
01756         }
01757 
01758       private:
01759         Background(Session *s, unsigned long i): NodeBase(s, i),
01760           groundAngle(this, 43),
01761           groundColor(this, 171),
01762           backUrl(this, 299),
01763           bottomUrl(this, 427),
01764           frontUrl(this, 555),
01765           leftUrl(this, 683),
01766           rightUrl(this, 811),
01767           topUrl(this, 939),
01768           skyAngle(this, 1067),
01769           skyColor(this, 1195) {}
01770 
01771       public:
01772         static NodeBase *instantiate(Session *s, unsigned long i)
01773         {
01774           return new Background(s, i);
01775         }
01776       };
01777 
01778 
01779 
01783       struct GeometryNode: virtual Node
01784       {
01785       protected:
01786         GeometryNode() {}
01787       };
01788 
01789 
01790 
01794       struct Geometry3DNode: GeometryNode
01795       {
01796       protected:
01797         Geometry3DNode() {}
01798       };
01799 
01800 
01801 
01805       struct Box: Geometry3DNode
01806       {
01807         static Ref<Box> create(Ref<ExecutionContext> c)
01808         {
01809           return NodeBase::create<Box>(c.get(), 46);
01810         }
01811 
01812         InitializeOnly<SFVec3f> size;
01813 
01814         /*
01815          * size
01816          */
01817         Vector3 getSize()
01818         {
01819           return size;
01820         }
01821         void setSize(Vector3 v)
01822         {
01823           size = v;
01824         }
01825 
01826       private:
01827         Box(Session *s, unsigned long i): NodeBase(s, i),
01828           size(this, 46) {}
01829 
01830       public:
01831         static NodeBase *instantiate(Session *s, unsigned long i)
01832         {
01833           return new Box(s, i);
01834         }
01835       };
01836 
01837 
01838 
01842       struct Cone: Geometry3DNode
01843       {
01844         static Ref<Cone> create(Ref<ExecutionContext> c)
01845         {
01846           return NodeBase::create<Cone>(c.get(), 47);
01847         }
01848 
01849         InitializeOnly<SFFloat> bottomRadius;
01850         InitializeOnly<SFFloat> height;
01851         InitializeOnly<SFBool> side;
01852         InitializeOnly<SFBool> bottom;
01853 
01854         /*
01855          * bottomRadius
01856          */
01857         double getBottomRadius()
01858         {
01859           return bottomRadius;
01860         }
01861         void setBottomRadius(double v)
01862         {
01863           bottomRadius = v;
01864         }
01865 
01866         /*
01867          * height
01868          */
01869         double getHeight()
01870         {
01871           return height;
01872         }
01873         void setHeight(double v)
01874         {
01875           height = v;
01876         }
01877 
01878         /*
01879          * side
01880          */
01881         bool getSide()
01882         {
01883           return side;
01884         }
01885         void setSide(bool v)
01886         {
01887           side = v;
01888         }
01889 
01890         /*
01891          * bottom
01892          */
01893         bool getBottom()
01894         {
01895           return bottom;
01896         }
01897         void setBottom(bool v)
01898         {
01899           bottom = v;
01900         }
01901 
01902       private:
01903         Cone(Session *s, unsigned long i): NodeBase(s, i),
01904           bottomRadius(this, 47),
01905           height(this, 175),
01906           side(this, 303),
01907           bottom(this, 431) {}
01908 
01909       public:
01910         static NodeBase *instantiate(Session *s, unsigned long i)
01911         {
01912           return new Cone(s, i);
01913         }
01914       };
01915 
01916 
01917 
01921       struct Cylinder: Geometry3DNode
01922       {
01923         static Ref<Cylinder> create(Ref<ExecutionContext> c)
01924         {
01925           return NodeBase::create<Cylinder>(c.get(), 48);
01926         }
01927 
01928         InitializeOnly<SFBool> bottom;
01929         InitializeOnly<SFFloat> radius;
01930         InitializeOnly<SFFloat> height;
01931         InitializeOnly<SFBool> side;
01932         InitializeOnly<SFBool> top;
01933 
01934         /*
01935          * bottom
01936          */
01937         bool getBottom()
01938         {
01939           return bottom;
01940         }
01941         void setBottom(bool v)
01942         {
01943           bottom = v;
01944         }
01945 
01946         /*
01947          * radius
01948          */
01949         double getRadius()
01950         {
01951           return radius;
01952         }
01953         void setRadius(double v)
01954         {
01955           radius = v;
01956         }
01957 
01958         /*
01959          * height
01960          */
01961         double getHeight()
01962         {
01963           return height;
01964         }
01965         void setHeight(double v)
01966         {
01967           height = v;
01968         }
01969 
01970         /*
01971          * side
01972          */
01973         bool getSide()
01974         {
01975           return side;
01976         }
01977         void setSide(bool v)
01978         {
01979           side = v;
01980         }
01981 
01982         /*
01983          * top
01984          */
01985         bool getTop()
01986         {
01987           return top;
01988         }
01989         void setTop(bool v)
01990         {
01991           top = v;
01992         }
01993 
01994       private:
01995         Cylinder(Session *s, unsigned long i): NodeBase(s, i),
01996           bottom(this, 48),
01997           radius(this, 176),
01998           height(this, 304),
01999           side(this, 432),
02000           top(this, 560) {}
02001 
02002       public:
02003         static NodeBase *instantiate(Session *s, unsigned long i)
02004         {
02005           return new Cylinder(s, i);
02006         }
02007       };
02008 
02009 
02010 
02014       struct IndexedLineSet: Geometry3DNode
02015       {
02016         static Ref<IndexedLineSet> create(Ref<ExecutionContext> c)
02017         {
02018           return NodeBase::create<IndexedLineSet>(c.get(), 49);
02019         }
02020 
02021         InputOutput<SFNode<ColorNode> > color;
02022         InputOutput<SFNode<CoordinateNode> > coord;
02023         InitializeOnlySeq<MFInt32> colorIndex;
02024         InputOnlySeq<MFInt32> set_colorIndex;
02025         InitializeOnly<SFBool> colorPerVertex;
02026         InitializeOnlySeq<MFInt32> coordIndex;
02027         InputOnlySeq<MFInt32> set_coordIndex;
02028         InitializeOnly<SFFloat> lineWidth;
02029 
02030         /*
02031          * color
02032          */
02033         Ref<ColorNode> getColor()
02034         {
02035           return color;
02036         }
02037         void setColor(Ref<ColorNode> v)
02038         {
02039           color = v;
02040         }
02041 
02042         /*
02043          * coord
02044          */
02045         Ref<CoordinateNode> getCoord()
02046         {
02047           return coord;
02048         }
02049         void setCoord(Ref<CoordinateNode> v)
02050         {
02051           coord = v;
02052         }
02053 
02054         /*
02055          * colorIndex
02056          */
02057         std::vector<int> getColorIndex()
02058         {
02059           return colorIndex;
02060         }
02061         void setColorIndex(const std::vector<int> &v)
02062         {
02063           colorIndex = v;
02064         }
02065 
02066         /*
02067          * set_colorIndex
02068          */
02069         void setSet_colorIndex(const std::vector<int> &v)
02070         {
02071           set_colorIndex = v;
02072         }
02073 
02074         /*
02075          * colorPerVertex
02076          */
02077         bool getColorPerVertex()
02078         {
02079           return colorPerVertex;
02080         }
02081         void setColorPerVertex(bool v)
02082         {
02083           colorPerVertex = v;
02084         }
02085 
02086         /*
02087          * coordIndex
02088          */
02089         std::vector<int> getCoordIndex()
02090         {
02091           return coordIndex;
02092         }
02093         void setCoordIndex(const std::vector<int> &v)
02094         {
02095           coordIndex = v;
02096         }
02097 
02098         /*
02099          * set_coordIndex
02100          */
02101         void setSet_coordIndex(const std::vector<int> &v)
02102         {
02103           set_coordIndex = v;
02104         }
02105 
02106         /*
02107          * lineWidth
02108          */
02109         double getLineWidth()
02110         {
02111           return lineWidth;
02112         }
02113         void setLineWidth(double v)
02114         {
02115           lineWidth = v;
02116         }
02117 
02118       private:
02119         IndexedLineSet(Session *s, unsigned long i): NodeBase(s, i),
02120           color(this, 49),
02121           coord(this, 177),
02122           colorIndex(this, 305),
02123           set_colorIndex(this, 433),
02124           colorPerVertex(this, 561),
02125           coordIndex(this, 689),
02126           set_coordIndex(this, 817),
02127           lineWidth(this, 945) {}
02128 
02129       public:
02130         static NodeBase *instantiate(Session *s, unsigned long i)
02131         {
02132           return new IndexedLineSet(s, i);
02133         }
02134       };
02135 
02136 
02137 
02141       struct PointSet: Geometry3DNode
02142       {
02143         static Ref<PointSet> create(Ref<ExecutionContext> c)
02144         {
02145           return NodeBase::create<PointSet>(c.get(), 50);
02146         }
02147 
02148         InputOutput<SFNode<ColorNode> > color;
02149         InputOutput<SFNode<CoordinateNode> > coord;
02150 
02151         /*
02152          * color
02153          */
02154         Ref<ColorNode> getColor()
02155         {
02156           return color;
02157         }
02158         void setColor(Ref<ColorNode> v)
02159         {
02160           color = v;
02161         }
02162 
02163         /*
02164          * coord
02165          */
02166         Ref<CoordinateNode> getCoord()
02167         {
02168           return coord;
02169         }
02170         void setCoord(Ref<CoordinateNode> v)
02171         {
02172           coord = v;
02173         }
02174 
02175       private:
02176         PointSet(Session *s, unsigned long i): NodeBase(s, i),
02177           color(this, 50),
02178           coord(this, 178) {}
02179 
02180       public:
02181         static NodeBase *instantiate(Session *s, unsigned long i)
02182         {
02183           return new PointSet(s, i);
02184         }
02185       };
02186 
02187 
02188 
02192       struct Sphere: Geometry3DNode
02193       {
02194         static Ref<Sphere> create(Ref<ExecutionContext> c)
02195         {
02196           return NodeBase::create<Sphere>(c.get(), 51);
02197         }
02198 
02199         InitializeOnly<SFFloat> radius;
02200 
02201         /*
02202          * radius
02203          */
02204         double getRadius()
02205         {
02206           return radius;
02207         }
02208         void setRadius(double v)
02209         {
02210           radius = v;
02211         }
02212 
02213       private:
02214         Sphere(Session *s, unsigned long i): NodeBase(s, i),
02215           radius(this, 51) {}
02216 
02217       public:
02218         static NodeBase *instantiate(Session *s, unsigned long i)
02219         {
02220           return new Sphere(s, i);
02221         }
02222       };
02223 
02224 
02225 
02229       struct ComposedGeometryNode: Geometry3DNode
02230       {
02231         InputOutput<SFNode<ColorNode> > color;
02232         InputOutput<SFNode<CoordinateNode> > coord;
02233         InputOutput<SFNode<NormalNode> > normal;
02234         InputOutput<SFNode<TextureCoordinateNode> > texCoord;
02235         InitializeOnly<SFBool> ccw;
02236         InitializeOnly<SFBool> colorPerVertex;
02237         InitializeOnly<SFBool> normalPerVertex;
02238         InitializeOnly<SFBool> solid;
02239 
02240         /*
02241          * color
02242          */
02243         Ref<ColorNode> getColor()
02244         {
02245           return color;
02246         }
02247         void setColor(Ref<ColorNode> v)
02248         {
02249           color = v;
02250         }
02251 
02252         /*
02253          * coord
02254          */
02255         Ref<CoordinateNode> getCoord()
02256         {
02257           return coord;
02258         }
02259         void setCoord(Ref<CoordinateNode> v)
02260         {
02261           coord = v;
02262         }
02263 
02264         /*
02265          * normal
02266          */
02267         Ref<NormalNode> getNormal()
02268         {
02269           return normal;
02270         }
02271         void setNormal(Ref<NormalNode> v)
02272         {
02273           normal = v;
02274         }
02275 
02276         /*
02277          * texCoord
02278          */
02279         Ref<TextureCoordinateNode> getTexCoord()
02280         {
02281           return texCoord;
02282         }
02283         void setTexCoord(Ref<TextureCoordinateNode> v)
02284         {
02285           texCoord = v;
02286         }
02287 
02288         /*
02289          * ccw
02290          */
02291         bool getCcw()
02292         {
02293           return ccw;
02294         }
02295         void setCcw(bool v)
02296         {
02297           ccw = v;
02298         }
02299 
02300         /*
02301          * colorPerVertex
02302          */
02303         bool getColorPerVertex()
02304         {
02305           return colorPerVertex;
02306         }
02307         void setColorPerVertex(bool v)
02308         {
02309           colorPerVertex = v;
02310         }
02311 
02312         /*
02313          * normalPerVertex
02314          */
02315         bool getNormalPerVertex()
02316         {
02317           return normalPerVertex;
02318         }
02319         void setNormalPerVertex(bool v)
02320         {
02321           normalPerVertex = v;
02322         }
02323 
02324         /*
02325          * solid
02326          */
02327         bool getSolid()
02328         {
02329           return solid;
02330         }
02331         void setSolid(bool v)
02332         {
02333           solid = v;
02334         }
02335 
02336       protected:
02337         ComposedGeometryNode():
02338           color(this, 52),
02339           coord(this, 180),
02340           normal(this, 308),
02341           texCoord(this, 436),
02342           ccw(this, 564),
02343           colorPerVertex(this, 692),
02344           normalPerVertex(this, 820),
02345           solid(this, 948) {}
02346       };
02347 
02348 
02349 
02353       struct IndexedFaceSet: ComposedGeometryNode
02354       {
02355         static Ref<IndexedFaceSet> create(Ref<ExecutionContext> c)
02356         {
02357           return NodeBase::create<IndexedFaceSet>(c.get(), 53);
02358         }
02359 
02360         InitializeOnly<SFBool> convex;
02361         InitializeOnlySeq<MFInt32> colorIndex;
02362         InputOnlySeq<MFInt32> set_colorIndex;
02363         InitializeOnlySeq<MFInt32> coordIndex;
02364         InputOnlySeq<MFInt32> set_coordIndex;
02365         InitializeOnly<SFFloat> creaseAngle;
02366         InitializeOnlySeq<MFInt32> normalIndex;
02367         InputOnlySeq<MFInt32> set_normalIndex;
02368         InitializeOnlySeq<MFInt32> texCoordIndex;
02369         InputOnlySeq<MFInt32> set_texCoordIndex;
02370 
02371         /*
02372          * convex
02373          */
02374         bool getConvex()
02375         {
02376           return convex;
02377         }
02378         void setConvex(bool v)
02379         {
02380           convex = v;
02381         }
02382 
02383         /*
02384          * colorIndex
02385          */
02386         std::vector<int> getColorIndex()
02387         {
02388           return colorIndex;
02389         }
02390         void setColorIndex(const std::vector<int> &v)
02391         {
02392           colorIndex = v;
02393         }
02394 
02395         /*
02396          * set_colorIndex
02397          */
02398         void setSet_colorIndex(const std::vector<int> &v)
02399         {
02400           set_colorIndex = v;
02401         }
02402 
02403         /*
02404          * coordIndex
02405          */
02406         std::vector<int> getCoordIndex()
02407         {
02408           return coordIndex;
02409         }
02410         void setCoordIndex(const std::vector<int> &v)
02411         {
02412           coordIndex = v;
02413         }
02414 
02415         /*
02416          * set_coordIndex
02417          */
02418         void setSet_coordIndex(const std::vector<int> &v)
02419         {
02420           set_coordIndex = v;
02421         }
02422 
02423         /*
02424          * creaseAngle
02425          */
02426         double getCreaseAngle()
02427         {
02428           return creaseAngle;
02429         }
02430         void setCreaseAngle(double v)
02431         {
02432           creaseAngle = v;
02433         }
02434 
02435         /*
02436          * normalIndex
02437          */
02438         std::vector<int> getNormalIndex()
02439         {
02440           return normalIndex;
02441         }
02442         void setNormalIndex(const std::vector<int> &v)
02443         {
02444           normalIndex = v;
02445         }
02446 
02447         /*
02448          * set_normalIndex
02449          */
02450         void setSet_normalIndex(const std::vector<int> &v)
02451         {
02452           set_normalIndex = v;
02453         }
02454 
02455         /*
02456          * texCoordIndex
02457          */
02458         std::vector<int> getTexCoordIndex()
02459         {
02460           return texCoordIndex;
02461         }
02462         void setTexCoordIndex(const std::vector<int> &v)
02463         {
02464           texCoordIndex = v;
02465         }
02466 
02467         /*
02468          * set_texCoordIndex
02469          */
02470         void setSet_texCoordIndex(const std::vector<int> &v)
02471         {
02472           set_texCoordIndex = v;
02473         }
02474 
02475       private:
02476         IndexedFaceSet(Session *s, unsigned long i): NodeBase(s, i),
02477           convex(this, 53),
02478           colorIndex(this, 181),
02479           set_colorIndex(this, 309),
02480           coordIndex(this, 437),
02481           set_coordIndex(this, 565),
02482           creaseAngle(this, 693),
02483           normalIndex(this, 821),
02484           set_normalIndex(this, 949),
02485           texCoordIndex(this, 1077),
02486           set_texCoordIndex(this, 1205) {}
02487 
02488       public:
02489         static NodeBase *instantiate(Session *s, unsigned long i)
02490         {
02491           return new IndexedFaceSet(s, i);
02492         }
02493       };
02494 
02495 
02496 
02500       struct ElevationGrid: ComposedGeometryNode
02501       {
02502         static Ref<ElevationGrid> create(Ref<ExecutionContext> c)
02503         {
02504           return NodeBase::create<ElevationGrid>(c.get(), 54);
02505         }
02506 
02507         InitializeOnly<SFFloat> creaseAngle;
02508         InitializeOnlySeq<MFFloat> height;
02509         InputOnlySeq<MFFloat> set_height;
02510         InitializeOnly<SFInt32> xDimension;
02511         InitializeOnly<SFFloat> xSpacing;
02512         InitializeOnly<SFInt32> zDimension;
02513         InitializeOnly<SFFloat> zSpacing;
02514 
02515         /*
02516          * creaseAngle
02517          */
02518         double getCreaseAngle()
02519         {
02520           return creaseAngle;
02521         }
02522         void setCreaseAngle(double v)
02523         {
02524           creaseAngle = v;
02525         }
02526 
02527         /*
02528          * height
02529          */
02530         std::vector<double> getHeight()
02531         {
02532           return height;
02533         }
02534         void setHeight(const std::vector<double> &v)
02535         {
02536           height = v;
02537         }
02538 
02539         /*
02540          * set_height
02541          */
02542         void setSet_height(const std::vector<double> &v)
02543         {
02544           set_height = v;
02545         }
02546 
02547         /*
02548          * xDimension
02549          */
02550         int getXDimension()
02551         {
02552           return xDimension;
02553         }
02554         void setXDimension(int v)
02555         {
02556           xDimension = v;
02557         }
02558 
02559         /*
02560          * xSpacing
02561          */
02562         double getXSpacing()
02563         {
02564           return xSpacing;
02565         }
02566         void setXSpacing(double v)
02567         {
02568           xSpacing = v;
02569         }
02570 
02571         /*
02572          * zDimension
02573          */
02574         int getZDimension()
02575         {
02576           return zDimension;
02577         }
02578         void setZDimension(int v)
02579         {
02580           zDimension = v;
02581         }
02582 
02583         /*
02584          * zSpacing
02585          */
02586         double getZSpacing()
02587         {
02588           return zSpacing;
02589         }
02590         void setZSpacing(double v)
02591         {
02592           zSpacing = v;
02593         }
02594 
02595       private:
02596         ElevationGrid(Session *s, unsigned long i): NodeBase(s, i),
02597           creaseAngle(this, 54),
02598           height(this, 182),
02599           set_height(this, 310),
02600           xDimension(this, 438),
02601           xSpacing(this, 566),
02602           zDimension(this, 694),
02603           zSpacing(this, 822) {}
02604 
02605       public:
02606         static NodeBase *instantiate(Session *s, unsigned long i)
02607         {
02608           return new ElevationGrid(s, i);
02609         }
02610       };
02611 
02612 
02613 
02617       struct ShapeNode: virtual ChildNode
02618       {
02619       protected:
02620         ShapeNode() {}
02621       };
02622 
02623 
02624 
02628       struct Shape: ShapeNode, BoundedObject
02629       {
02630         static Ref<Shape> create(Ref<ExecutionContext> c)
02631         {
02632           return NodeBase::create<Shape>(c.get(), 56);
02633         }
02634 
02635         InputOutput<SFNode<AppearanceNode> > appearance;
02636         InputOutput<SFNode<GeometryNode> > geometry;
02637 
02638         /*
02639          * appearance
02640          */
02641         Ref<AppearanceNode> getAppearance()
02642         {
02643           return appearance;
02644         }
02645         void setAppearance(Ref<AppearanceNode> v)
02646         {
02647           appearance = v;
02648         }
02649 
02650         /*
02651          * geometry
02652          */
02653         Ref<GeometryNode> getGeometry()
02654         {
02655           return geometry;
02656         }
02657         void setGeometry(Ref<GeometryNode> v)
02658         {
02659           geometry = v;
02660         }
02661 
02662       private:
02663         Shape(Session *s, unsigned long i): NodeBase(s, i),
02664           appearance(this, 56),
02665           geometry(this, 184) {}
02666 
02667       public:
02668         static NodeBase *instantiate(Session *s, unsigned long i)
02669         {
02670           return new Shape(s, i);
02671         }
02672       };
02673 
02674 
02675 
02679       struct FontStyleNode: GeometricPropertyNode
02680       {
02681       protected:
02682         FontStyleNode() {}
02683       };
02684 
02685 
02686 
02690       struct FontStyle: FontStyleNode
02691       {
02692         static Ref<FontStyle> create(Ref<ExecutionContext> c)
02693         {
02694           return NodeBase::create<FontStyle>(c.get(), 58);
02695         }
02696 
02697         InitializeOnlySeq<MFString> family;
02698         InitializeOnly<SFBool> horizontal;
02699         InitializeOnlySeq<MFString> justify;
02700         InitializeOnly<SFString> language;
02701         InitializeOnly<SFBool> leftToRight;
02702         InitializeOnly<SFFloat> size;
02703         InitializeOnly<SFFloat> spacing;
02704         InitializeOnly<SFString> style;
02705         InitializeOnly<SFBool> topToBottom;
02706 
02707         /*
02708          * family
02709          */
02710         std::vector<std::string> getFamily()
02711         {
02712           return family;
02713         }
02714         void setFamily(const std::vector<std::string> &v)
02715         {
02716           family = v;
02717         }
02718 
02719         /*
02720          * horizontal
02721          */
02722         bool getHorizontal()
02723         {
02724           return horizontal;
02725         }
02726         void setHorizontal(bool v)
02727         {
02728           horizontal = v;
02729         }
02730 
02731         /*
02732          * justify
02733          */
02734         std::vector<std::string> getJustify()
02735         {
02736           return justify;
02737         }
02738         void setJustify(const std::vector<std::string> &v)
02739         {
02740           justify = v;
02741         }
02742 
02743         /*
02744          * language
02745          */
02746         std::string getLanguage()
02747         {
02748           return language;
02749         }
02750         void setLanguage(std::string v)
02751         {
02752           language = v;
02753         }
02754 
02755         /*
02756          * leftToRight
02757          */
02758         bool getLeftToRight()
02759         {
02760           return leftToRight;
02761         }
02762         void setLeftToRight(bool v)
02763         {
02764           leftToRight = v;
02765         }
02766 
02767         /*
02768          * size
02769          */
02770         double getSize()
02771         {
02772           return size;
02773         }
02774         void setSize(double v)
02775         {
02776           size = v;
02777         }
02778 
02779         /*
02780          * spacing
02781          */
02782         double getSpacing()
02783         {
02784           return spacing;
02785         }
02786         void setSpacing(double v)
02787         {
02788           spacing = v;
02789         }
02790 
02791         /*
02792          * style
02793          */
02794         std::string getStyle()
02795         {
02796           return style;
02797         }
02798         void setStyle(std::string v)
02799         {
02800           style = v;
02801         }
02802 
02803         /*
02804          * topToBottom
02805          */
02806         bool getTopToBottom()
02807         {
02808           return topToBottom;
02809         }
02810         void setTopToBottom(bool v)
02811         {
02812           topToBottom = v;
02813         }
02814 
02815       private:
02816         FontStyle(Session *s, unsigned long i): NodeBase(s, i),
02817           family(this, 58),
02818           horizontal(this, 186),
02819           justify(this, 314),
02820           language(this, 442),
02821           leftToRight(this, 570),
02822           size(this, 698),
02823           spacing(this, 826),
02824           style(this, 954),
02825           topToBottom(this, 1082) {}
02826 
02827       public:
02828         static NodeBase *instantiate(Session *s, unsigned long i)
02829         {
02830           return new FontStyle(s, i);
02831         }
02832       };
02833 
02834 
02835 
02839       struct TextNode: GeometryNode
02840       {
02841       protected:
02842         TextNode() {}
02843       };
02844 
02845 
02846 
02850       struct Text: TextNode
02851       {
02852         static Ref<Text> create(Ref<ExecutionContext> c)
02853         {
02854           return NodeBase::create<Text>(c.get(), 60);
02855         }
02856 
02857         InputOutputSeq<MFString> string;
02858         InputOutput<SFNode<FontStyleNode> > fontStyle;
02859         InputOutputSeq<MFFloat> length;
02860         InputOutput<SFFloat> maxExtent;
02861         InitializeOnly<SFBool> solid;
02862 
02863         /*
02864          * string
02865          */
02866         std::vector<std::string> getString()
02867         {
02868           return string;
02869         }
02870         void setString(const std::vector<std::string> &v)
02871         {
02872           string = v;
02873         }
02874 
02875         /*
02876          * fontStyle
02877          */
02878         Ref<FontStyleNode> getFontStyle()
02879         {
02880           return fontStyle;
02881         }
02882         void setFontStyle(Ref<FontStyleNode> v)
02883         {
02884           fontStyle = v;
02885         }
02886 
02887         /*
02888          * length
02889          */
02890         std::vector<double> getLength()
02891         {
02892           return length;
02893         }
02894         void setLength(const std::vector<double> &v)
02895         {
02896           length = v;
02897         }
02898 
02899         /*
02900          * maxExtent
02901          */
02902         double getMaxExtent()
02903         {
02904           return maxExtent;
02905         }
02906         void setMaxExtent(double v)
02907         {
02908           maxExtent = v;
02909         }
02910 
02911         /*
02912          * solid
02913          */
02914         bool getSolid()
02915         {
02916           return solid;
02917         }
02918         void setSolid(bool v)
02919         {
02920           solid = v;
02921         }
02922 
02923       private:
02924         Text(Session *s, unsigned long i): NodeBase(s, i),
02925           string(this, 60),
02926           fontStyle(this, 188),
02927           length(this, 316),
02928           maxExtent(this, 444),
02929           solid(this, 572) {}
02930 
02931       public:
02932         static NodeBase *instantiate(Session *s, unsigned long i)
02933         {
02934           return new Text(s, i);
02935         }
02936       };
02937 
02938 
02939 
02943       struct LightNode: virtual ChildNode
02944       {
02945         InputOutput<SFFloat> ambientIntensity;
02946         InputOutput<SFColor> color;
02947         InputOutput<SFFloat> intensity;
02948         InputOutput<SFBool> on;
02949 
02950         /*
02951          * ambientIntensity
02952          */
02953         double getAmbientIntensity()
02954         {
02955           return ambientIntensity;
02956         }
02957         void setAmbientIntensity(double v)
02958         {
02959           ambientIntensity = v;
02960         }
02961 
02962         /*
02963          * color
02964          */
02965         Vector3 getColor()
02966         {
02967           return color;
02968         }
02969         void setColor(Vector3 v)
02970         {
02971           color = v;
02972         }
02973 
02974         /*
02975          * intensity
02976          */
02977         double getIntensity()
02978         {
02979           return intensity;
02980         }
02981         void setIntensity(double v)
02982         {
02983           intensity = v;
02984         }
02985 
02986         /*
02987          * on
02988          */
02989         bool getOn()
02990         {
02991           return on;
02992         }
02993         void setOn(bool v)
02994         {
02995           on = v;
02996         }
02997 
02998       protected:
02999         LightNode():
03000           ambientIntensity(this, 61),
03001           color(this, 189),
03002           intensity(this, 317),
03003           on(this, 445) {}
03004       };
03005 
03006 
03007 
03011       struct DirectionalLight: LightNode
03012       {
03013         static Ref<DirectionalLight> create(Ref<ExecutionContext> c)
03014         {
03015           return NodeBase::create<DirectionalLight>(c.get(), 62);
03016         }
03017 
03018         InputOutput<SFVec3f> direction;
03019 
03020         /*
03021          * direction
03022          */
03023         Vector3 getDirection()
03024         {
03025           return direction;
03026         }
03027         void setDirection(Vector3 v)
03028         {
03029           direction = v;
03030         }
03031 
03032       private:
03033         DirectionalLight(Session *s, unsigned long i): NodeBase(s, i),
03034           direction(this, 62) {}
03035 
03036       public:
03037         static NodeBase *instantiate(Session *s, unsigned long i)
03038         {
03039           return new DirectionalLight(s, i);
03040         }
03041       };
03042 
03043 
03044 
03048       struct PointLight: LightNode
03049       {
03050         static Ref<PointLight> create(Ref<ExecutionContext> c)
03051         {
03052           return NodeBase::create<PointLight>(c.get(), 63);
03053         }
03054 
03055         InputOutput<SFVec3f> attenuation;
03056         InputOutput<SFVec3f> location;
03057         InputOutput<SFFloat> radius;
03058 
03059         /*
03060          * attenuation
03061          */
03062         Vector3 getAttenuation()
03063         {
03064           return attenuation;
03065         }
03066         void setAttenuation(Vector3 v)
03067         {
03068           attenuation = v;
03069         }
03070 
03071         /*
03072          * location
03073          */
03074         Vector3 getLocation()
03075         {
03076           return location;
03077         }
03078         void setLocation(Vector3 v)
03079         {
03080           location = v;
03081         }
03082 
03083         /*
03084          * radius
03085          */
03086         double getRadius()
03087         {
03088           return radius;
03089         }
03090         void setRadius(double v)
03091         {
03092           radius = v;
03093         }
03094 
03095       private:
03096         PointLight(Session *s, unsigned long i): NodeBase(s, i),
03097           attenuation(this, 63),
03098           location(this, 191),
03099           radius(this, 319) {}
03100 
03101       public:
03102         static NodeBase *instantiate(Session *s, unsigned long i)
03103         {
03104           return new PointLight(s, i);
03105         }
03106       };
03107 
03108 
03109 
03113       struct SpotLight: LightNode
03114       {
03115         static Ref<SpotLight> create(Ref<ExecutionContext> c)
03116         {
03117           return NodeBase::create<SpotLight>(c.get(), 64);
03118         }
03119 
03120         InputOutput<SFVec3f> attenuation;
03121         InputOutput<SFFloat> beamWidth;
03122         InputOutput<SFFloat> cutOffAngle;
03123         InputOutput<SFVec3f> direction;
03124         InputOutput<SFVec3f> location;
03125         InputOutput<SFFloat> radius;
03126 
03127         /*
03128          * attenuation
03129          */
03130         Vector3 getAttenuation()
03131         {
03132           return attenuation;
03133         }
03134         void setAttenuation(Vector3 v)
03135         {
03136           attenuation = v;
03137         }
03138 
03139         /*
03140          * beamWidth
03141          */
03142         double getBeamWidth()
03143         {
03144           return beamWidth;
03145         }
03146         void setBeamWidth(double v)
03147         {
03148           beamWidth = v;
03149         }
03150 
03151         /*
03152          * cutOffAngle
03153          */
03154         double getCutOffAngle()
03155         {
03156           return cutOffAngle;
03157         }
03158         void setCutOffAngle(double v)
03159         {
03160           cutOffAngle = v;
03161         }
03162 
03163         /*
03164          * direction
03165          */
03166         Vector3 getDirection()
03167         {
03168           return direction;
03169         }
03170         void setDirection(Vector3 v)
03171         {
03172           direction = v;
03173         }
03174 
03175         /*
03176          * location
03177          */
03178         Vector3 getLocation()
03179         {
03180           return location;
03181         }
03182         void setLocation(Vector3 v)
03183         {
03184           location = v;
03185         }
03186 
03187         /*
03188          * radius
03189          */
03190         double getRadius()
03191         {
03192           return radius;
03193         }
03194         void setRadius(double v)
03195         {
03196           radius = v;
03197         }
03198 
03199       private:
03200         SpotLight(Session *s, unsigned long i): NodeBase(s, i),
03201           attenuation(this, 64),
03202           beamWidth(this, 192),
03203           cutOffAngle(this, 320),
03204           direction(this, 448),
03205           location(this, 576),
03206           radius(this, 704) {}
03207 
03208       public:
03209         static NodeBase *instantiate(Session *s, unsigned long i)
03210         {
03211           return new SpotLight(s, i);
03212         }
03213       };
03214 
03215 
03216 
03220       struct InterpolatorNode: virtual ChildNode
03221       {
03222         InputOnly<SFFloat> set_fraction;
03223         InputOutputSeq<MFFloat> key;
03224 
03225         /*
03226          * set_fraction
03227          */
03228         void setSet_fraction(double v)
03229         {
03230           set_fraction = v;
03231         }
03232 
03233         /*
03234          * key
03235          */
03236         std::vector<double> getKey()
03237         {
03238           return key;
03239         }
03240         void setKey(const std::vector<double> &v)
03241         {
03242           key = v;
03243         }
03244 
03245       protected:
03246         InterpolatorNode():
03247           set_fraction(this, 65),
03248           key(this, 193) {}
03249       };
03250 
03251 
03252 
03256       struct ColorInterpolator: InterpolatorNode
03257       {
03258         static Ref<ColorInterpolator> create(Ref<ExecutionContext> c)
03259         {
03260           return NodeBase::create<ColorInterpolator>(c.get(), 66);
03261         }
03262 
03263         InputOutputSeq<MFColor> keyValue;
03264         OutputOnly<SFColor> value_changed;
03265 
03266         /*
03267          * keyValue
03268          */
03269         std::vector<Vector3> getKeyValue()
03270         {
03271           return keyValue;
03272         }
03273         void setKeyValue(const std::vector<Vector3> &v)
03274         {
03275           keyValue = v;
03276         }
03277 
03278         /*
03279          * value_changed
03280          */
03281         Vector3 getValue_changed()
03282         {
03283           return value_changed;
03284         }
03285 
03286       private:
03287         ColorInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03288           keyValue(this, 66),
03289           value_changed(this, 194) {}
03290 
03291       public:
03292         static NodeBase *instantiate(Session *s, unsigned long i)
03293         {
03294           return new ColorInterpolator(s, i);
03295         }
03296       };
03297 
03298 
03299 
03303       struct CoordinateInterpolator: InterpolatorNode
03304       {
03305         static Ref<CoordinateInterpolator> create(Ref<ExecutionContext> c)
03306         {
03307           return NodeBase::create<CoordinateInterpolator>(c.get(), 67);
03308         }
03309 
03310         InputOutputSeq<MFVec3f> keyValue;
03311         OutputOnlySeq<MFVec3f> value_changed;
03312 
03313         /*
03314          * keyValue
03315          */
03316         std::vector<Vector3> getKeyValue()
03317         {
03318           return keyValue;
03319         }
03320         void setKeyValue(const std::vector<Vector3> &v)
03321         {
03322           keyValue = v;
03323         }
03324 
03325         /*
03326          * value_changed
03327          */
03328         std::vector<Vector3> getValue_changed()
03329         {
03330           return value_changed;
03331         }
03332 
03333       private:
03334         CoordinateInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03335           keyValue(this, 67),
03336           value_changed(this, 195) {}
03337 
03338       public:
03339         static NodeBase *instantiate(Session *s, unsigned long i)
03340         {
03341           return new CoordinateInterpolator(s, i);
03342         }
03343       };
03344 
03345 
03346 
03350       struct CoordinateInterpolator2D: InterpolatorNode
03351       {
03352         static Ref<CoordinateInterpolator2D> create(Ref<ExecutionContext> c)
03353         {
03354           return NodeBase::create<CoordinateInterpolator2D>(c.get(), 68);
03355         }
03356 
03357         InputOutputSeq<MFVec2f> keyValue;
03358         OutputOnlySeq<MFVec2f> value_changed;
03359 
03360         /*
03361          * keyValue
03362          */
03363         std::vector<Vector2> getKeyValue()
03364         {
03365           return keyValue;
03366         }
03367         void setKeyValue(const std::vector<Vector2> &v)
03368         {
03369           keyValue = v;
03370         }
03371 
03372         /*
03373          * value_changed
03374          */
03375         std::vector<Vector2> getValue_changed()
03376         {
03377           return value_changed;
03378         }
03379 
03380       private:
03381         CoordinateInterpolator2D(Session *s, unsigned long i): NodeBase(s, i),
03382           keyValue(this, 68),
03383           value_changed(this, 196) {}
03384 
03385       public:
03386         static NodeBase *instantiate(Session *s, unsigned long i)
03387         {
03388           return new CoordinateInterpolator2D(s, i);
03389         }
03390       };
03391 
03392 
03393 
03397       struct NormalInterpolator: InterpolatorNode
03398       {
03399         static Ref<NormalInterpolator> create(Ref<ExecutionContext> c)
03400         {
03401           return NodeBase::create<NormalInterpolator>(c.get(), 69);
03402         }
03403 
03404         InputOutputSeq<MFVec3f> keyValue;
03405         OutputOnlySeq<MFVec3f> value_changed;
03406 
03407         /*
03408          * keyValue
03409          */
03410         std::vector<Vector3> getKeyValue()
03411         {
03412           return keyValue;
03413         }
03414         void setKeyValue(const std::vector<Vector3> &v)
03415         {
03416           keyValue = v;
03417         }
03418 
03419         /*
03420          * value_changed
03421          */
03422         std::vector<Vector3> getValue_changed()
03423         {
03424           return value_changed;
03425         }
03426 
03427       private:
03428         NormalInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03429           keyValue(this, 69),
03430           value_changed(this, 197) {}
03431 
03432       public:
03433         static NodeBase *instantiate(Session *s, unsigned long i)
03434         {
03435           return new NormalInterpolator(s, i);
03436         }
03437       };
03438 
03439 
03440 
03444       struct OrientationInterpolator: InterpolatorNode
03445       {
03446         static Ref<OrientationInterpolator> create(Ref<ExecutionContext> c)
03447         {
03448           return NodeBase::create<OrientationInterpolator>(c.get(), 70);
03449         }
03450 
03451         InputOutputSeq<MFRotation> keyValue;
03452         OutputOnly<SFRotation> value_changed;
03453 
03454         /*
03455          * keyValue
03456          */
03457         std::vector<Rotation3> getKeyValue()
03458         {
03459           return keyValue;
03460         }
03461         void setKeyValue(const std::vector<Rotation3> &v)
03462         {
03463           keyValue = v;
03464         }
03465 
03466         /*
03467          * value_changed
03468          */
03469         Rotation3 getValue_changed()
03470         {
03471           return value_changed;
03472         }
03473 
03474       private:
03475         OrientationInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03476           keyValue(this, 70),
03477           value_changed(this, 198) {}
03478 
03479       public:
03480         static NodeBase *instantiate(Session *s, unsigned long i)
03481         {
03482           return new OrientationInterpolator(s, i);
03483         }
03484       };
03485 
03486 
03487 
03491       struct PositionInterpolator: InterpolatorNode
03492       {
03493         static Ref<PositionInterpolator> create(Ref<ExecutionContext> c)
03494         {
03495           return NodeBase::create<PositionInterpolator>(c.get(), 71);
03496         }
03497 
03498         InputOutputSeq<MFVec3f> keyValue;
03499         OutputOnly<SFVec3f> value_changed;
03500 
03501         /*
03502          * keyValue
03503          */
03504         std::vector<Vector3> getKeyValue()
03505         {
03506           return keyValue;
03507         }
03508         void setKeyValue(const std::vector<Vector3> &v)
03509         {
03510           keyValue = v;
03511         }
03512 
03513         /*
03514          * value_changed
03515          */
03516         Vector3 getValue_changed()
03517         {
03518           return value_changed;
03519         }
03520 
03521       private:
03522         PositionInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03523           keyValue(this, 71),
03524           value_changed(this, 199) {}
03525 
03526       public:
03527         static NodeBase *instantiate(Session *s, unsigned long i)
03528         {
03529           return new PositionInterpolator(s, i);
03530         }
03531       };
03532 
03533 
03534 
03538       struct PositionInterpolator2D: InterpolatorNode
03539       {
03540         static Ref<PositionInterpolator2D> create(Ref<ExecutionContext> c)
03541         {
03542           return NodeBase::create<PositionInterpolator2D>(c.get(), 72);
03543         }
03544 
03545         InputOutputSeq<MFVec2f> keyValue;
03546         OutputOnly<SFVec2f> value_changed;
03547 
03548         /*
03549          * keyValue
03550          */
03551         std::vector<Vector2> getKeyValue()
03552         {
03553           return keyValue;
03554         }
03555         void setKeyValue(const std::vector<Vector2> &v)
03556         {
03557           keyValue = v;
03558         }
03559 
03560         /*
03561          * value_changed
03562          */
03563         Vector2 getValue_changed()
03564         {
03565           return value_changed;
03566         }
03567 
03568       private:
03569         PositionInterpolator2D(Session *s, unsigned long i): NodeBase(s, i),
03570           keyValue(this, 72),
03571           value_changed(this, 200) {}
03572 
03573       public:
03574         static NodeBase *instantiate(Session *s, unsigned long i)
03575         {
03576           return new PositionInterpolator2D(s, i);
03577         }
03578       };
03579 
03580 
03581 
03585       struct ScalarInterpolator: InterpolatorNode
03586       {
03587         static Ref<ScalarInterpolator> create(Ref<ExecutionContext> c)
03588         {
03589           return NodeBase::create<ScalarInterpolator>(c.get(), 73);
03590         }
03591 
03592         InputOutputSeq<MFFloat> keyValue;
03593         OutputOnly<SFFloat> value_changed;
03594 
03595         /*
03596          * keyValue
03597          */
03598         std::vector<double> getKeyValue()
03599         {
03600           return keyValue;
03601         }
03602         void setKeyValue(const std::vector<double> &v)
03603         {
03604           keyValue = v;
03605         }
03606 
03607         /*
03608          * value_changed
03609          */
03610         double getValue_changed()
03611         {
03612           return value_changed;
03613         }
03614 
03615       private:
03616         ScalarInterpolator(Session *s, unsigned long i): NodeBase(s, i),
03617           keyValue(this, 73),
03618           value_changed(this, 201) {}
03619 
03620       public:
03621         static NodeBase *instantiate(Session *s, unsigned long i)
03622         {
03623           return new ScalarInterpolator(s, i);
03624         }
03625       };
03626 
03627 
03628 
03632       struct Billboard: GroupingNode, BoundedObject
03633       {
03634         static Ref<Billboard> create(Ref<ExecutionContext> c)
03635         {
03636           return NodeBase::create<Billboard>(c.get(), 74);
03637         }
03638 
03639         InputOutput<SFVec3f> axisOfRotation;
03640 
03641         /*
03642          * axisOfRotation
03643          */
03644         Vector3 getAxisOfRotation()
03645         {
03646           return axisOfRotation;
03647         }
03648         void setAxisOfRotation(Vector3 v)
03649         {
03650           axisOfRotation = v;
03651         }
03652 
03653       private:
03654         Billboard(Session *s, unsigned long i): NodeBase(s, i),
03655           axisOfRotation(this, 74) {}
03656 
03657       public:
03658         static NodeBase *instantiate(Session *s, unsigned long i)
03659         {
03660           return new Billboard(s, i);
03661         }
03662       };
03663 
03664 
03665 
03669       struct Viewpoint: BindableNode
03670       {
03671         static Ref<Viewpoint> create(Ref<ExecutionContext> c)
03672         {
03673           return NodeBase::create<Viewpoint>(c.get(), 75);
03674         }
03675 
03676         InputOutput<SFBool> jump;
03677         InputOutput<SFVec3f> position;
03678         InputOutput<SFRotation> orientation;
03679         InputOutput<SFFloat> fieldOfView;
03680         InputOutput<SFVec3f> centerOfRotation;
03681         InitializeOnly<SFString> description;
03682 
03683         /*
03684          * jump
03685          */
03686         bool getJump()
03687         {
03688           return jump;
03689         }
03690         void setJump(bool v)
03691         {
03692           jump = v;
03693         }
03694 
03695         /*
03696          * position
03697          */
03698         Vector3 getPosition()
03699         {
03700           return position;
03701         }
03702         void setPosition(Vector3 v)
03703         {
03704           position = v;
03705         }
03706 
03707         /*
03708          * orientation
03709          */
03710         Rotation3 getOrientation()
03711         {
03712           return orientation;
03713         }
03714         void setOrientation(Rotation3 v)
03715         {
03716           orientation = v;
03717         }
03718 
03719         /*
03720          * fieldOfView
03721          */
03722         double getFieldOfView()
03723         {
03724           return fieldOfView;
03725         }
03726         void setFieldOfView(double v)
03727         {
03728           fieldOfView = v;
03729         }
03730 
03731         /*
03732          * centerOfRotation
03733          */
03734         Vector3 getCenterOfRotation()
03735         {
03736           return centerOfRotation;
03737         }
03738         void setCenterOfRotation(Vector3 v)
03739         {
03740           centerOfRotation = v;
03741         }
03742 
03743         /*
03744          * description
03745          */
03746         std::string getDescription()
03747         {
03748           return description;
03749         }
03750         void setDescription(std::string v)
03751         {
03752           description = v;
03753         }
03754 
03755       private:
03756         Viewpoint(Session *s, unsigned long i): NodeBase(s, i),
03757           jump(this, 75),
03758           position(this, 203),
03759           orientation(this, 331),
03760           fieldOfView(this, 459),
03761           centerOfRotation(this, 587),
03762           description(this, 715) {}
03763 
03764       public:
03765         static NodeBase *instantiate(Session *s, unsigned long i)
03766         {
03767           return new Viewpoint(s, i);
03768         }
03769       };
03770 
03771 
03772 
03776       struct PointingDeviceSensorNode: SensorNode
03777       {
03778         InputOutput<SFString> description;
03779         OutputOnly<SFBool> isOver;
03780 
03781         /*
03782          * description
03783          */
03784         std::string getDescription()
03785         {
03786           return description;
03787         }
03788         void setDescription(std::string v)
03789         {
03790           description = v;
03791         }
03792 
03793         /*
03794          * isOver
03795          */
03796         bool getIsOver()
03797         {
03798           return isOver;
03799         }
03800 
03801       protected:
03802         PointingDeviceSensorNode():
03803           description(this, 76),
03804           isOver(this, 204) {}
03805       };
03806 
03807 
03808 
03812       struct DragSensorNode: PointingDeviceSensorNode
03813       {
03814         InputOutput<SFBool> autoOffset;
03815         OutputOnly<SFVec3f> trackPoint_changed;
03816 
03817         /*
03818          * autoOffset
03819          */
03820         bool getAutoOffset()
03821         {
03822           return autoOffset;
03823         }
03824         void setAutoOffset(bool v)
03825         {
03826           autoOffset = v;
03827         }
03828 
03829         /*
03830          * trackPoint_changed
03831          */
03832         Vector3 getTrackPoint_changed()
03833         {
03834           return trackPoint_changed;
03835         }
03836 
03837       protected:
03838         DragSensorNode():
03839           autoOffset(this, 77),
03840           trackPoint_changed(this, 205) {}
03841       };
03842 
03843 
03844 
03848       struct PlaneSensor: DragSensorNode
03849       {
03850         static Ref<PlaneSensor> create(Ref<ExecutionContext> c)
03851         {
03852           return NodeBase::create<PlaneSensor>(c.get(), 78);
03853         }
03854 
03855         InputOutput<SFVec2f> maxPosition;
03856         InputOutput<SFVec2f> minPosition;
03857         InputOutput<SFVec3f> offset;
03858         OutputOnly<SFVec3f> translation_changed;
03859 
03860         /*
03861          * maxPosition
03862          */
03863         Vector2 getMaxPosition()
03864         {
03865           return maxPosition;
03866         }
03867         void setMaxPosition(Vector2 v)
03868         {
03869           maxPosition = v;
03870         }
03871 
03872         /*
03873          * minPosition
03874          */
03875         Vector2 getMinPosition()
03876         {
03877           return minPosition;
03878         }
03879         void setMinPosition(Vector2 v)
03880         {
03881           minPosition = v;
03882         }
03883 
03884         /*
03885          * offset
03886          */
03887         Vector3 getOffset()
03888         {
03889           return offset;
03890         }
03891         void setOffset(Vector3 v)
03892         {
03893           offset = v;
03894         }
03895 
03896         /*
03897          * translation_changed
03898          */
03899         Vector3 getTranslation_changed()
03900         {
03901           return translation_changed;
03902         }
03903 
03904       private:
03905         PlaneSensor(Session *s, unsigned long i): NodeBase(s, i),
03906           maxPosition(this, 78),
03907           minPosition(this, 206),
03908           offset(this, 334),
03909           translation_changed(this, 462) {}
03910 
03911       public:
03912         static NodeBase *instantiate(Session *s, unsigned long i)
03913         {
03914           return new PlaneSensor(s, i);
03915         }
03916       };
03917 
03918 
03919 
03923       struct SphereSensor: DragSensorNode
03924       {
03925         static Ref<SphereSensor> create(Ref<ExecutionContext> c)
03926         {
03927           return NodeBase::create<SphereSensor>(c.get(), 79);
03928         }
03929 
03930         InputOutput<SFRotation> offset;
03931         OutputOnly<SFRotation> rotation_changed;
03932 
03933         /*
03934          * offset
03935          */
03936         Rotation3 getOffset()
03937         {
03938           return offset;
03939         }
03940         void setOffset(Rotation3 v)
03941         {
03942           offset = v;
03943         }
03944 
03945         /*
03946          * rotation_changed
03947          */
03948         Rotation3 getRotation_changed()
03949         {
03950           return rotation_changed;
03951         }
03952 
03953       private:
03954         SphereSensor(Session *s, unsigned long i): NodeBase(s, i),
03955           offset(this, 79),
03956           rotation_changed(this, 207) {}
03957 
03958       public:
03959         static NodeBase *instantiate(Session *s, unsigned long i)
03960         {
03961           return new SphereSensor(s, i);
03962         }
03963       };
03964 
03965 
03966 
03970       struct CylinderSensor: DragSensorNode
03971       {
03972         static Ref<CylinderSensor> create(Ref<ExecutionContext> c)
03973         {
03974           return NodeBase::create<CylinderSensor>(c.get(), 80);
03975         }
03976 
03977         InputOutput<SFFloat> diskAngle;
03978         InputOutput<SFFloat> maxAngle;
03979         InputOutput<SFFloat> minAngle;
03980         InputOutput<SFFloat> offset;
03981         OutputOnly<SFRotation> rotation_changed;
03982 
03983         /*
03984          * diskAngle
03985          */
03986         double getDiskAngle()
03987         {
03988           return diskAngle;
03989         }
03990         void setDiskAngle(double v)
03991         {
03992           diskAngle = v;
03993         }
03994 
03995         /*
03996          * maxAngle
03997          */
03998         double getMaxAngle()
03999         {
04000           return maxAngle;
04001         }
04002         void setMaxAngle(double v)
04003         {
04004           maxAngle = v;
04005         }
04006 
04007         /*
04008          * minAngle
04009          */
04010         double getMinAngle()
04011         {
04012           return minAngle;
04013         }
04014         void setMinAngle(double v)
04015         {
04016           minAngle = v;
04017         }
04018 
04019         /*
04020          * offset
04021          */
04022         double getOffset()
04023         {
04024           return offset;
04025         }
04026         void setOffset(double v)
04027         {
04028           offset = v;
04029         }
04030 
04031         /*
04032          * rotation_changed
04033          */
04034         Rotation3 getRotation_changed()
04035         {
04036           return rotation_changed;
04037         }
04038 
04039       private:
04040         CylinderSensor(Session *s, unsigned long i): NodeBase(s, i),
04041           diskAngle(this, 80),
04042           maxAngle(this, 208),
04043           minAngle(this, 336),
04044           offset(this, 464),
04045           rotation_changed(this, 592) {}
04046 
04047       public:
04048         static NodeBase *instantiate(Session *s, unsigned long i)
04049         {
04050           return new CylinderSensor(s, i);
04051         }
04052       };
04053 
04054 
04055 
04059       struct TouchSensorNode: PointingDeviceSensorNode
04060       {
04061         OutputOnly<SFTime> touchTime;
04062 
04063         /*
04064          * touchTime
04065          */
04066         Time getTouchTime()
04067         {
04068           return touchTime;
04069         }
04070 
04071       protected:
04072         TouchSensorNode():
04073           touchTime(this, 81) {}
04074       };
04075 
04076 
04077 
04081       struct TouchSensor: TouchSensorNode
04082       {
04083         static Ref<TouchSensor> create(Ref<ExecutionContext> c)
04084         {
04085           return NodeBase::create<TouchSensor>(c.get(), 82);
04086         }
04087 
04088         OutputOnly<SFVec3f> hitNormal_changed;
04089         OutputOnly<SFVec3f> hitPoint_changed;
04090         OutputOnly<SFVec2f> hitTexCoord_changed;
04091 
04092         /*
04093          * hitNormal_changed
04094          */
04095         Vector3 getHitNormal_changed()
04096         {
04097           return hitNormal_changed;
04098         }
04099 
04100         /*
04101          * hitPoint_changed
04102          */
04103         Vector3 getHitPoint_changed()
04104         {
04105           return hitPoint_changed;
04106         }
04107 
04108         /*
04109          * hitTexCoord_changed
04110          */
04111         Vector2 getHitTexCoord_changed()
04112         {
04113           return hitTexCoord_changed;
04114         }
04115 
04116       private:
04117         TouchSensor(Session *s, unsigned long i): NodeBase(s, i),
04118           hitNormal_changed(this, 82),
04119           hitPoint_changed(this, 210),
04120           hitTexCoord_changed(this, 338) {}
04121 
04122       public:
04123         static NodeBase *instantiate(Session *s, unsigned long i)
04124         {
04125           return new TouchSensor(s, i);
04126         }
04127       };
04128 
04129 
04130 
04134       struct ScriptNode: virtual ChildNode
04135       {
04136       protected:
04137         ScriptNode() {}
04138       };
04139 
04140 
04141 
04145       struct Script: ScriptNode, UrlObject
04146       {
04147         static Ref<Script> create(Ref<ExecutionContext> c)
04148         {
04149           return NodeBase::create<Script>(c.get(), 84);
04150         }
04151 
04152         InitializeOnly<SFBool> directOutput;
04153         InitializeOnly<SFBool> mustEvaluate;
04154 
04155         /*
04156          * directOutput
04157          */
04158         bool getDirectOutput()
04159         {
04160           return directOutput;
04161         }
04162         void setDirectOutput(bool v)
04163         {
04164           directOutput = v;
04165         }
04166 
04167         /*
04168          * mustEvaluate
04169          */
04170         bool getMustEvaluate()
04171         {
04172           return mustEvaluate;
04173         }
04174         void setMustEvaluate(bool v)
04175         {
04176           mustEvaluate = v;
04177         }
04178 
04179       private:
04180         Script(Session *s, unsigned long i): NodeBase(s, i),
04181           directOutput(this, 84),
04182           mustEvaluate(this, 212) {}
04183 
04184       public:
04185         static NodeBase *instantiate(Session *s, unsigned long i)
04186         {
04187           return new Script(s, i);
04188         }
04189       };
04190 
04191 
04192 
04196       struct Torus: Geometry3DNode
04197       {
04198         static Ref<Torus> create(Ref<ExecutionContext> c)
04199         {
04200           return NodeBase::create<Torus>(c.get(), 85);
04201         }
04202 
04203         InitializeOnly<SFFloat> majorRadius;
04204         InitializeOnly<SFFloat> minorRadius;
04205 
04206         /*
04207          * majorRadius
04208          */
04209         double getMajorRadius()
04210         {
04211           return majorRadius;
04212         }
04213         void setMajorRadius(double v)
04214         {
04215           majorRadius = v;
04216         }
04217 
04218         /*
04219          * minorRadius
04220          */
04221         double getMinorRadius()
04222         {
04223           return minorRadius;
04224         }
04225         void setMinorRadius(double v)
04226         {
04227           minorRadius = v;
04228         }
04229 
04230       private:
04231         Torus(Session *s, unsigned long i): NodeBase(s, i),
04232           majorRadius(this, 85),
04233           minorRadius(this, 213) {}
04234 
04235       public:
04236         static NodeBase *instantiate(Session *s, unsigned long i)
04237         {
04238           return new Torus(s, i);
04239         }
04240       };
04241     }
04242   }
04243 }
04244 
04245 #endif // ARCHON_X3D_PROXY_NODE_AUTOGEN_H

Generated on Sun Jul 30 22:55:47 2006 for Archon by  doxygen 1.4.4