1 /* 2 * Node.h 3 * 4 * Copyright (C) 1999 Stephen F. White, 2005 J. "MUFTI" Scheurich 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program (see the file "COPYING" for details); if 18 * not, write to the Free Software Foundation, Inc., 675 Mass Ave, 19 * Cambridge, MA 02139, USA. 20 */ 21 22 #pragma once 23 24 #include <stdio.h> 25 #include "Array.h" 26 #include "List.h" 27 #include "Vec3f.h" 28 #include "MyString.h" 29 #include "FieldIndex.h" 30 #include "Element.h" 31 32 #include "NodeFlags.h" 33 #include "MeshFlags.h" 34 #include "ac3dMaterialCallback.h" 35 #include "NodeArray.h" 36 #include "Stack.h" 37 #include "Matrix.h" 38 #include "Quaternion.h" 39 40 class FieldValue; 41 class Node; 42 class Scene; 43 class NodePROTO; 44 class Path; 45 class NodeList; 46 class EventOut; 47 class EventIn; 48 class Field; 49 class ExposedField; 50 class MyMesh; 51 class MFVec3f; 52 class MFVec2f; 53 class NodeHAnimHumanoid; 54 class SFFloat; 55 class SFNode; 56 57 class RouteSocket { 58 public: RouteSocket()59 RouteSocket() 60 { 61 m_node = NULL; 62 m_field = -1; 63 } RouteSocket(Node * node,int index)64 RouteSocket(Node *node, int index) 65 { 66 m_node = node; 67 m_field = index; 68 } 69 70 int operator==(const RouteSocket &t) 71 { return t.m_node == m_node && t.m_field == m_field; } 72 73 int operator!=(const RouteSocket &t) 74 { return t.m_node != m_node || t.m_field != m_field; } 75 getNode(void)76 Node *getNode(void) const { return m_node; } getField(void)77 int getField(void) const { return m_field; } 78 protected: 79 Node *m_node; 80 int m_field; 81 }; 82 83 typedef List<RouteSocket> SocketList; 84 85 enum parentFlag { 86 PARENT_NOT_TOUCHED, 87 PARENT_TOUCHED, 88 PARENT_RECURSIVE 89 }; 90 91 class Parent { 92 public: Parent()93 Parent() 94 { 95 m_node = NULL; 96 m_field = -1; 97 m_self = NULL; 98 m_parentFlag = PARENT_NOT_TOUCHED; 99 } 100 Parent(Node * node,int field,Node * self)101 Parent(Node *node, int field, Node *self) 102 { 103 m_node = node; 104 m_field = field; 105 m_self = self; 106 m_parentFlag = PARENT_NOT_TOUCHED; 107 } 108 109 int operator==(const Parent &t) 110 { return t.m_self == m_self; } 111 112 int operator!=(const Parent &t) 113 { return t.m_self != m_self; } 114 115 Node *m_node; 116 int m_field; 117 Node *m_self; 118 parentFlag m_parentFlag; 119 }; 120 121 typedef MyArray<Parent> ParentArray; 122 123 enum Constraint { 124 CONSTRAIN_NONE = 0, 125 CONSTRAIN_X, 126 CONSTRAIN_Y, 127 CONSTRAIN_Z, 128 CONSTRAIN_XY, 129 CONSTRAIN_YZ, 130 CONSTRAIN_ZX, 131 CONSTRAIN_SPHERE 132 }; 133 134 135 // X3D_NODE_TYPE 136 enum NodeEnum { 137 VRML_ANCHOR, 138 VRML_APPEARANCE, 139 X3D_ARC_2D, 140 X3D_ARC_CLOSE_2D, 141 COVER_AR_SENSOR, 142 VRML_AUDIO_CLIP, 143 VRML_BACKGROUND, 144 X3D_BALL_JOINT, 145 X3DOM_BINARY_GEOMETRY, 146 VRML_BILLBOARD, 147 X3DOM_BLOCK, 148 KAMBI_BLEND_MODE, 149 X3D_BLENDED_VOLUME_STYLE, 150 X3D_BOOLEAN_FILTER, 151 X3D_BOOLEAN_TOGGLE, 152 X3D_BOOLEAN_TRIGGER, 153 X3D_BOOLEAN_SEQUENCER, 154 X3D_BOUNDARY_ENHANCEMENT_VOLUME_STYLE, 155 X3D_BOUNDED_PHYSICS_MODEL, 156 VRML_BOX, 157 X3D_CAD_ASSEMBLY, 158 X3D_CAD_FACE, 159 X3D_CAD_LAYER, 160 X3D_CAD_PART, 161 X3D_CARTOON_VOLUME_STYLE, 162 DUNE_CATT_EXPORT_REC, // Export container node for CATT 8 file format 163 DUNE_CATT_EXPORT_SRC, // Export container node for CATT 8 file format 164 X3D_CIRCLE_2D, 165 X3D_CLIP_PLANE, 166 X3D_COLLIDABLE_OFFSET, 167 X3D_COLLIDABLE_SHAPE, 168 VRML_COLLISION, 169 X3D_COLLISION_COLLECTION, 170 X3D_COLLISION_SENSOR, 171 X3D_COLLISION_SPACE, 172 VRML_COLOR, 173 X3D_COLOR_CHASER, 174 X3D_COLOR_DAMPER, 175 VRML_COLOR_INTERPOLATOR, 176 X3DOM_COLOR_MASK_MODE, 177 X3D_COLOR_RGBA, 178 KAMBI_COLOR_SET_INTERPOLATOR, 179 X3DOM_COMMON_SURFACE_SHADER, 180 X3D_COMPOSED_CUBE_MAP_TEXTURE, 181 X3D_COMPOSED_SHADER, 182 X3D_COMPOSED_TEXTURE_3D, 183 X3D_COMPOSED_VOLUME_STYLE, 184 VRML_CONE, 185 X3D_CONE_EMITTER, 186 X3D_CONTACT, 187 VRML_CONTOUR_2D, 188 X3D_CONTOUR_POLYLINE_2D, 189 VRML_COORDINATE, 190 X3D_COORDINATE_CHASER, 191 X3D_COORDINATE_DAMPER, 192 VRML_COORDINATE_DEFORMER, 193 X3D_COORDINATE_DOUBLE, 194 VRML_COORDINATE_INTERPOLATOR, 195 X3D_COORDINATE_INTERPOLATOR_2D, 196 COVER_COVER, 197 COVER_CUBE_TEXTURE, 198 KAMBI_CUBIC_BEZIER_2D_ORIENTATION_INTERPOLATOR, 199 KAMBI_CUBIC_BEZIER_POSITION_INTERPOLATOR, 200 DUNE_CURVE_ANIMATION, 201 VRML_CYLINDER, 202 VRML_CYLINDER_SENSOR, 203 X3DOM_DEPTH_MODE, 204 VRML_DIRECTIONAL_LIGHT, 205 X3DOM_DISH, 206 X3D_DIS_ENTITY_MANAGER, 207 X3D_DIS_ENTITY_TYPE_MAPPING, 208 X3D_DISK_2D, 209 X3DOM_DYNAMIC_LOD, 210 X3D_DOUBLE_AXIS_HINGE_JOINT, 211 X3D_EASE_IN_EASE_OUT, 212 KAMBI_EFFECT, 213 KAMBI_EFFECT_PART, 214 X3D_EDGE_ENHANCEMENT_VOLUME_STYLE, 215 VRML_ELEVATION_GRID, 216 X3DOM_ENVIRONMENT, 217 X3D_ESPDU_TRANSFORM, 218 X3D_EXPLOSION_EMITTER, 219 X3DOM_EXTERNAL_GEOMETRY, 220 VRML_EXTRUSION, 221 X3DOM_FIELD, 222 X3D_FILL_PROPERTIES, 223 X3D_FLOAT_VERTEX_ATTRIBUTE, 224 VRML_FOG, 225 X3D_FOG_COORDINATE, 226 VRML_FONT_STYLE, 227 X3D_FORCE_PHYSICS_MODEL, 228 X3D_GENERATED_CUBE_MAP_TEXTURE, 229 KAMBI_GENERATED_SHADOW_MAP, 230 VRML_GEO_COORDINATE, 231 VRML_GEO_ELEVATION_GRID, 232 VRML_GEO_LOCATION, 233 VRML_GEO_LOD, 234 X3D_GEO_METADATA, 235 VRML_GEO_ORIGIN, 236 VRML_GEO_POSITION_INTERPOLATOR, 237 X3D_GEO_PROXIMITY_SENSOR, 238 VRML_GEO_TOUCH_SENSOR, 239 X3D_GEO_TRANSFORM, 240 VRML_GEO_VIEWPOINT, 241 VRML_GROUP, 242 X3D_HANIM_DISPLACER, 243 X3D_HANIM_HUMANOID, 244 X3D_HANIM_JOINT, 245 X3D_HANIM_MOTION, 246 X3D_HANIM_SEGMENT, 247 X3D_HANIM_SITE, 248 X3D_IMAGE_CUBE_MAP_TEXTURE, 249 X3DOM_IMAGE_GEOMETRY, 250 VRML_IMAGE_TEXTURE, 251 X3D_IMAGE_TEXTURE_3D, 252 X3DOM_IMAGE_TEXTURE_ATLAS, 253 VRML_INDEXED_FACE_SET, 254 VRML_INDEXED_LINE_SET, 255 X3D_INDEXED_QUAD_SET, 256 X3D_INDEXED_TRIANGLE_FAN_SET, 257 X3D_INDEXED_TRIANGLE_SET, 258 X3D_INDEXED_TRIANGLE_STRIP_SET, 259 VRML_INLINE, 260 VRML_INLINE_LOAD_CONTROL, 261 X3D_INTEGER_SEQUENCER, 262 X3D_INTEGER_TRIGGER, 263 X3D_ISO_SURFACE_VOLUME_DATA, 264 COVER_JOYSTICK_SENSOR, 265 KAMBI_KAMBI_APPEARANCE, 266 KAMBI_KAMBI_HEAD_LIGHT, 267 KAMBI_KAMBI_INLINE, 268 KAMBI_KAMBI_NAVIGATION_INFO, 269 KAMBI_KAMBI_OCTREE_PROPERTIES, 270 KAMBI_KAMBI_TRIANGULATION, 271 X3D_KEY_SENSOR, 272 COVER_LAB_VIEW, 273 X3D_LAYER, 274 X3D_LAYER_SET, 275 X3D_LAYOUT, 276 X3D_LAYOUT_GROUP, 277 X3D_LAYOUT_LAYER, 278 DUNE_LDRAW_DAT_EXPORT, // Export container node for ldraw.dat file format 279 X3D_LINE_PICK_SENSOR, 280 X3D_LINE_PROPERTIES, 281 X3D_LINE_SET, 282 X3D_LOAD_SENSOR, 283 X3D_LOCAL_FOG, 284 VRML_LOD, 285 VRML_MATERIAL, 286 X3D_MATRIX_3_VERTEX_ATTRIBUTE, 287 X3D_MATRIX_4_VERTEX_ATTRIBUTE, 288 KAMBI_MATRIX_TRANSFORM, 289 X3DOM_MESH, 290 X3D_METADATA_BOOLEAN, 291 X3D_METADATA_DOUBLE, 292 X3D_METADATA_FLOAT, 293 X3D_METADATA_INTEGER, 294 X3D_METADATA_SET, 295 X3D_METADATA_STRING, 296 X3D_MOTOR_JOINT, 297 VRML_MOVIE_TEXTURE, 298 X3DOM_MPR_VOLUME_STYLE, 299 KAMBI_MULTI_GENERATED_TEXTURE_COORDINATE, 300 X3DOM_MULTI_PART, 301 X3D_MULTI_TEXTURE, 302 X3D_MULTI_TEXTURE_COORDINATE, 303 X3D_MULTI_TEXTURE_TRANSFORM, 304 VRML_NAVIGATION_INFO, 305 VRML_NORMAL, 306 VRML_NORMAL_INTERPOLATOR, 307 X3DOM_NOZZLE, 308 VRML_NURBS_CURVE, 309 VRML_NURBS_CURVE_2D, 310 VRML_NURBS_GROUP, 311 X3D_NURBS_ORIENTATION_INTERPOLATOR, 312 VRML_NURBS_POSITION_INTERPOLATOR, 313 X3D_NURBS_SET, 314 VRML_NURBS_SURFACE, 315 X3D_NURBS_SURFACE_INTERPOLATOR, 316 X3D_NURBS_SWEPT_SURFACE, 317 X3D_NURBS_SWUNG_SURFACE, 318 X3D_NURBS_TEXTURE_COORDINATE, 319 VRML_NURBS_TEXTURE_SURFACE, 320 X3D_NURBS_TRIMMED_SURFACE, 321 X3D_OPACITY_MAP_VOLUME_STYLE, 322 X3D_ORIENTATION_CHASER, 323 X3D_ORIENTATION_DAMPER, 324 VRML_ORIENTATION_INTERPOLATOR, 325 X3D_ORTHO_VIEWPOINT, 326 X3D_PACKAGED_SHADER, 327 X3DOM_PARAM, 328 X3DOM_PARTICLE_SET, 329 X3D_PARTICLE_SYSTEM, 330 X3D_PICKABLE_GROUP, 331 VRML_PIXEL_TEXTURE, 332 X3D_PIXEL_TEXTURE_3D, 333 X3DOM_PLANE, 334 VRML_PLANE_SENSOR, 335 X3D_POINT_EMITTER, 336 VRML_POINT_LIGHT, 337 X3D_POINT_PICK_SENSOR, 338 X3D_POINT_PROPERTIES, 339 VRML_POINT_SET, 340 VRML_POLYLINE_2D, 341 X3D_POLYLINE_EMITTER, 342 X3D_POLYPOINT_2D, 343 X3DOM_POP_GEOMETRY, 344 X3DOM_POP_GEOMETRY_LEVEL, 345 X3D_POSITION_CHASER_2D, 346 X3D_POSITION_CHASER, 347 X3D_POSITION_DAMPER_2D, 348 X3D_POSITION_DAMPER, 349 VRML_POSITION_INTERPOLATOR, 350 X3D_POSITION_INTERPOLATOR_2D, 351 X3D_PRIMITIVE_PICK_SENSOR, 352 X3D_PROGRAM_SHADER, 353 KAMBI_PROJECTED_TEXTURE_COORDINATE, 354 X3D_PROJECTION_VOLUME_STYLE, 355 VRML_PROXIMITY_SENSOR, 356 X3DOM_PYRAMID, 357 X3D_QUAD_SET, 358 X3DOM_RADAR_VOLUME_STYLE, 359 X3D_RECEIVER_PDU, 360 X3D_RECTANGLE_2D, 361 X3DOM_RECTANGULAR_TORUS, 362 X3DOM_REFINEMENT_TEXTURE, 363 X3DOM_REMOTE_SELECTION_GROUP, 364 KAMBI_RENDERED_TEXTURE, 365 X3D_RIGID_BODY, 366 X3D_RIGID_BODY_COLLECTION, 367 X3D_SCALAR_CHASER, 368 X3D_SCALAR_DAMPER, 369 VRML_SCALAR_INTERPOLATOR, 370 KAMBI_SCREEN_EFFECT, 371 X3D_SCREEN_FONT_STYLE, 372 X3D_SCREEN_GROUP, 373 VRML_SCRIPT, 374 X3D_SEGMENTED_VOLUME_DATA, 375 X3D_SHADED_VOLUME_STYLE, 376 X3D_SHADER_PART, 377 X3D_SHADER_PROGRAM, 378 KAMBI_SHADER_TEXTURE, 379 VRML_SHAPE, 380 X3D_SIGNAL_PDU, 381 X3D_SINGLE_AXIS_HINGE_JOINT, 382 X3D_SILHOUETTE_ENHANCEMENT_VOLUME_STYLE, 383 COVER_SKY, 384 X3D_SLIDER_JOINT, 385 X3DOM_SLOPED_CYLINDER, 386 X3DOM_SNOUT, 387 X3DOM_SOLID_OF_REVOLUTION, 388 VRML_SOUND, 389 COVER_SPACE_SENSOR, 390 VRML_SPHERE, 391 X3DOM_SPHERE_SEGMENT, 392 VRML_SPHERE_SENSOR, 393 X3D_SPLINE_POSITION_INTERPOLATOR, 394 X3D_SPLINE_POSITION_INTERPOLATOR_2D, 395 X3D_SPLINE_SCALAR_INTERPOLATOR, 396 VRML_SPOT_LIGHT, 397 X3D_SQUAD_ORIENTATION_INTERPOLATOR, 398 X3D_STATIC_GROUP, 399 X3DOM_STIPPLE_VOLUME_STYLE, 400 X3D_STRING_SENSOR, 401 COVER_STEERING_WHEEL, 402 DUNE_SUPER_ELLIPSOID, 403 DUNE_SUPER_EXTRUSION, 404 DUNE_SUPER_REVOLVER, 405 DUNE_SUPER_SHAPE, 406 X3D_SURFACE_EMITTER, 407 X3DOM_SURFACE_SHADER_TEXTURE, 408 VRML_SWITCH, 409 KAMBI_TEAPOT, 410 X3D_TEX_COORD_CHASER_2D, 411 X3D_TEX_COORD_DAMPER_2D, 412 VRML_TEXT, 413 KAMBI_TEXT_3D, 414 X3D_TEXTURE_BACKGROUND, 415 VRML_TEXTURE_COORDINATE, 416 X3D_TEXTURE_COORDINATE_3D, 417 X3D_TEXTURE_COORDINATE_4D, 418 X3D_TEXTURE_COORDINATE_GENERATOR, 419 X3D_TEXTURE_PROPERTIES, 420 VRML_TEXTURE_TRANSFORM, 421 X3D_TEXTURE_TRANSFORM_3D, 422 X3D_TEXTURE_TRANSFORM_MATRIX_3D, 423 VRML_TIME_SENSOR, 424 X3D_TIME_TRIGGER, 425 X3D_TONE_MAPPED_VOLUME_STYLE, 426 X3DOM_TORUS, 427 VRML_TOUCH_SENSOR, 428 VRML_TRANSFORM, 429 X3D_TRANSFORM_SENSOR, 430 X3D_TRANSMITTER_PDU, 431 X3D_TRIANGLE_FAN_SET, 432 X3D_TRIANGLE_SET, 433 X3D_TRIANGLE_SET_2D, 434 X3D_TRIANGLE_STRIP_SET, 435 VRML_TRIMMED_SURFACE, 436 COVER_TUI_BUTTON, 437 COVER_TUI_COMBO_BOX, 438 COVER_TUI_FLOAT_SLIDER, 439 COVER_TUI_FRAME, 440 COVER_TUI_LABEL, 441 COVER_TUI_LIST_BOX, 442 COVER_TUI_MAP, 443 COVER_TUI_PROGRESS_BAR, 444 COVER_TUI_SLIDER, 445 COVER_TUI_SPLITTER, 446 COVER_TUI_TAB, 447 COVER_TUI_TAB_FOLDER, 448 COVER_TUI_TOGGLE_BUTTON, 449 X3D_TWO_SIDED_MATERIAL, 450 X3DOM_UNIFORM, 451 X3D_UNIVERSAL_JOINT, 452 COVER_VEHICLE, 453 KAMBI_VECTOR_INTERPOLATOR, 454 X3DOM_VIEWFRUSTUM, 455 VRML_VIEWPOINT, 456 X3D_VIEWPOINT_GROUP, 457 X3D_VIEWPORT, 458 COVER_VIRTUAL_ACOUSTICS, 459 COVER_VIRTUAL_SOUND_SOURCE, 460 VRML_VISIBILITY_SENSOR, 461 X3D_VOLUME_DATA, 462 X3D_VOLUME_EMITTER, 463 X3D_VOLUME_PICK_SENSOR, 464 DUNE_VRML_CUT, 465 DUNE_VRML_SCENE, 466 COVER_WAVE, 467 X3D_WIND_PHYSICS_MODEL, 468 DUNE_WONDERLAND_IMPORT_JAVA, 469 VRML_WORLD_INFO, 470 471 // fake nodes 472 VRML_COMMENT, 473 X3D_EXPORT, 474 X3D_IMPORT, 475 476 // the following are node "classes", used to validate the 477 // scene graph hierarchy 478 479 ANY_NODE, 480 AUDIO_CLIP_NODE, 481 BODY_COLLIDABLE_NODE, 482 BODY_COLLISION_SPACE_NODE, 483 BOUNDED_OBJECT_NODE, 484 COMPOSABLE_VOLUME_RENDER_STYLE_NODE, 485 COORDINATE_NODE, 486 FONT_STYLE_NODE, 487 HANIM_CHILD_NODE, 488 INLINE_NODE, 489 INTERPOLATOR_NODE, 490 MATERIAL_NODE, 491 METADATA_NODE, 492 MOVIE_TEXTURE_NODE, 493 NURBS_CONTROL_CURVE_NODE, 494 NURBS_TEXTURE_COORDINATE_NODE, 495 LAYER_NODE, 496 LIGHT_NODE, 497 LINE_SET_NODE, 498 LOD_NODE, 499 PARAMETRIC_GEOMETRY_NODE, 500 PARTICLE_EMITTER_NODE, 501 PARTICLE_PHYSICS_MODEL_NODE, 502 PRODUCT_STRUCTURE_CHILD_NODE, 503 PRIMITIVE_GEOMETRY_NODE, 504 RIGID_JOINT_NODE, 505 ROOT_NODE, // still a dummy 506 SHAPE_NODE, 507 SHADER_NODE, 508 TEXTURE_3D_NODE, 509 VERTEX_ATTRIBUTE_NODE, 510 VIEWPOINT_NODE, 511 VIEWPOINT_GROUP_NODE, 512 VOLUME_DATA_NODE, 513 514 // combined types 515 AUDIO_CLIP_OR_MOVIE_TEXTURE_NODE, 516 BODY_COLLIDABLE_OR_BODY_COLLISION_SPACE_NODE, 517 VOLUME_RENDER_STYLE_NODE, 518 GENERATED_TEXTURE_COORDINATE_NODE, 519 NURBS_TEXTURE_COORDINATE_OR_TEXTURE_COORDINATE_NODE, 520 PRIMITIVE_GEOMETRY_OR_MASS_DENSITY_MODEL_NODE, 521 SHAPE_OR_INLINE_NODE, 522 SHAPE_OR_LOD_NODE, 523 SPOTLIGHT_OR_DIRECTIONALLIGHT_OR_VIEWPOINT_NODE, 524 TEXTURE_OR_TEXTURE_3D_NODE, 525 VIEWPOINT_OR_VIEWPOINT_GROUP_NODE, 526 NURBS_CURVE_2D_OR_CONTOUR_POLYLINE_2D_NODE, 527 528 // the nodeclass of the following types can be bitwise OR'ed to any node 529 NOT_SELF_NODE = 1 << 19, 530 SENSOR_NODE = 1 << 20, 531 TEXTURE_COORDINATE_NODE = 1 << 21, 532 TEXTURE_TRANSFORM_NODE = 1 << 22, 533 TEXTURE_NODE = 1 << 23, 534 TEXTURE_2D_NODE = 1 << 24, 535 GEOMETRY_NODE = 1 << 25, 536 COLOR_NODE = 1 << 26, 537 CHILD_NODE = 1 << 27, 538 GROUPING_NODE = 1 << 28, 539 URL_NODE = 1 << 29, 540 PROTO_NODE = 1 << 30 541 // do not use bit 31 (sign bit) 542 }; 543 544 #define LAST_NODE VRML_COMMENT 545 546 enum { 547 PROFILE_CORE, 548 PROFILE_INTERCHANGE, 549 PROFILE_CAD_INTERCHANGE, 550 PROFILE_INTERACTIVE, 551 PROFILE_MPEG4_INTERACTIVE, 552 PROFILE_IMMERSIVE, 553 PROFILE_FULL 554 }; 555 556 typedef enum { 557 XZ_DIRECTION, 558 XY_DIRECTION, 559 YZ_DIRECTION 560 } Direction; 561 562 enum xmlWriteFlag { 563 XML_PROTO_INSTANCE_FIELD, 564 XML_IN_TAG, 565 XML_IS, 566 XML_NODE 567 }; 568 569 class EventOutData { 570 public: 571 int eventOut; 572 int numOutput; 573 Node *protoNode; 574 }; 575 576 class Colored; 577 class NodeColor; 578 class NodeColorRGBA; 579 class NodeCoordinate; 580 581 class NodeData { 582 public: 583 NodeData(Scene *scene, Proto *proto); 584 NodeData(const Node &node); 585 virtual ~NodeData(); 586 587 void initIdentifier(void); 588 589 void delete_this(void); isClassType(int type)590 bool isClassType(int type) { return type >= ANY_NODE; } 591 bool matchNodeClass(int childType) const; 592 593 virtual int writeProto(int filedes); 594 int writeProto(int f, const char *urn, 595 const char *directoryName, 596 const char *haveUrl = "", 597 bool nameInUrl = true); 598 int writeX3dProto(int filedes); 599 600 int writeProtoArguments(int filedes) const; avoidProtoOnPureVrml(void)601 virtual bool avoidProtoOnPureVrml(void) { return false; } 602 virtual bool canWriteAc3d(); 603 virtual int writeAc3d(int filedes, int indent); writeAc3dMaterial(int filedes,int indent,const char * name)604 virtual int writeAc3dMaterial(int filedes, int indent, 605 const char *name) { return 0; } setAc3dMaterialIndex(int index)606 virtual void setAc3dMaterialIndex(int index) {} getIncAc3dMaterialIndex(void)607 virtual int getIncAc3dMaterialIndex(void) { return 0; } 608 virtual void handleAc3dMaterial(ac3dMaterialCallback callback, 609 Scene* scene); 610 611 virtual int writeRib(int filedes, int indent); 612 virtual int writePovray(int filedes, int indent); 613 614 virtual bool canWriteLdrawDat(); 615 virtual int writeLdrawDat(int filedes, int indent); 616 getScene()617 Scene *getScene() const { return m_scene; } 618 virtual FieldValue *getField(int index) const; 619 virtual void setField(int index, FieldValue *value, 620 int containerField = -1); 621 getField(FieldIndex index)622 virtual FieldValue *getField(FieldIndex index) const 623 { return getField((int) index); } setField(FieldIndex index,FieldValue * value)624 virtual void setField(FieldIndex index, FieldValue *value) 625 { setField((int) index, value); } 626 627 virtual FieldValue *getUntranslatedField(int index) const; 628 getTreeLabel(void)629 const char *getTreeLabel(void) { return m_treeLabel; } 630 const MyString &getName(void); 631 const MyString &getNameOrNewName(void); 632 // setName should only be called from Scene::def 633 void setName(const char *name); 634 bool hasName(void); 635 bool needsDEF() const; 636 637 virtual void addToConvertedNodes(int writeFlags); 638 getNumConvertedNodes()639 int getNumConvertedNodes() { return m_convertedNodes.size(); } getConvertedNode(int i)640 Node *getConvertedNode(int i) { return m_convertedNodes[i]; } 641 void deleteConvertedNodes(void); 642 643 bool needExtraJavaClass(void); 644 bool writeJavaOutsideClass(int languageFlag); 645 isConvertedInCurveAnimaton(void)646 virtual bool isConvertedInCurveAnimaton(void) 647 { return m_isConvertedInCurveAnimaton; } setConvertedInCurveAnimaton(void)648 void setConvertedInCurveAnimaton(void) 649 { m_isConvertedInCurveAnimaton = true; } 650 getGraphPosition(float * x,float * y)651 void getGraphPosition(float *x, float *y) const 652 { *x = m_graphX; *y = m_graphY; } setGraphPosition(float x,float y)653 void setGraphPosition(float x, float y) 654 { m_graphX = x; m_graphY = y; } 655 getGraphSize(int * width,int * height)656 void getGraphSize(int *width, int *height) const 657 { *width = m_graphWidth; *height = m_graphHeight; } setGraphSize(int width,int height)658 void setGraphSize(int width, int height) 659 { m_graphWidth = width; m_graphHeight = height; } 660 ref()661 void ref() { m_refs++; } unref()662 void unref() 663 { 664 if (--m_refs == 0) 665 delete_this(); 666 } getRefs()667 int getRefs() { return m_refs; } 668 onAddRoute(Node * s,int out,Node * d,int in)669 virtual void onAddRoute(Node *s, int out, Node *d, int in) {} 670 671 virtual int getType() const; 672 virtual int getNodeClass() const; getProfile(void)673 virtual int getProfile(void) const { return -1; } 674 getComponentName(void)675 virtual const char* getComponentName(void) const { return ""; } getComponentLevel(void)676 virtual int getComponentLevel(void) const { return -1; } 677 678 int getMaskedNodeClass(void); 679 680 virtual Node *copy() const = 0; 681 void copyData(const NodeData &node); 682 683 int findChild(Node *child, int field) const; 684 685 int lookupEventIn(const char *name, bool x3d) const; 686 int lookupEventOut(const char *name, bool x3d) const; 687 getProto()688 Proto *getProto() const { return m_proto; } setProto(Proto * proto)689 void setProto(Proto *proto) { m_proto = proto; } getPrimaryProto()690 virtual Proto *getPrimaryProto() const { return getProto(); } 691 692 virtual void addInput(int eventIn, Node *src, int eventOut); 693 virtual void addOutput(int eventOut, Node *dst, int eventIn); 694 virtual void removeInput(int eventIn, Node *src, int eventOut); 695 virtual void removeOutput(int eventOut, Node *dst, int eventIn); getInput(int i)696 const SocketList &getInput(int i) const { return m_inputs[i]; } getOutput(int i)697 const SocketList &getOutput(int i) const { return m_outputs[i]; } 698 699 virtual void update(); 700 virtual void reInit(); 701 updateTime()702 virtual void updateTime() {} 703 validate(void)704 virtual bool validate(void) { return true; } 705 setInternal(bool flag)706 virtual void setInternal(bool flag) {} 707 hasNumbers4kids(void)708 virtual bool hasNumbers4kids(void) { return false; } 709 maySetDefault(void)710 virtual bool maySetDefault(void) { return true; } 711 getNumParents()712 int getNumParents() const { return m_parents.size(); } 713 void copyParentList(const Node &node); 714 715 bool checkValid(Element *field); 716 bool validChild(int field, Node *child); 717 bool validChildType(int field, int childType); 718 int findValidField(Node *child); 719 int findValidFieldType(int childType); 720 int findFirstValidFieldType(int childType); 721 bool checkChildType(int field, int childType, 722 bool checkValid = false); 723 int findChildType(int childType); 724 getFlag(int flag)725 bool getFlag(int flag) const 726 { return (m_flags & (1 << flag)) != 0; } setFlag(int flag)727 void setFlag(int flag) { m_flags |= (1 << flag); } 728 void setFlagRec(int flag); clearFlag(int flag)729 void clearFlag(int flag) { m_flags &= ~(1 << flag); } 730 void clearFlagRec(int flag); 731 isCollapsed()732 bool isCollapsed() const 733 { return getFlag(NODE_FLAG_COLLAPSED); } 734 transform()735 virtual void transform() {} transformBranch()736 virtual void transformBranch() {} transformForHandle(int handle)737 virtual void transformForHandle(int handle) {} preDraw()738 virtual void preDraw() {} specialDraw()739 virtual void specialDraw() {} draw()740 virtual void draw() {} draw(int pass)741 virtual void draw(int pass) {} canDraw()742 bool canDraw() { return m_canDraw; } bind()743 virtual void bind() {} unbind()744 virtual void unbind() {} bind(GLuint textureId,GLuint textureUnit)745 virtual void bind(GLuint textureId, GLuint textureUnit) {} load()746 virtual void load() {} drawHandles()747 virtual void drawHandles() {} updateHandles()748 virtual void updateHandles() {} drawJointHandles(float scale,Node * parent,Node * that)749 virtual void drawJointHandles(float scale, Node *parent, Node *that) 750 {} 751 /// countPolygons() do not count polygons in primitives countPolygons(void)752 virtual int countPolygons(void) {return 0;} countPrimitives(void)753 virtual int countPrimitives(void) {return 0;} countPolygons1Sided(void)754 virtual int countPolygons1Sided(void) {return 0;} countPolygons2Sided(void)755 virtual int countPolygons2Sided(void) {return 0;} 756 757 virtual bool isMesh(void); getMesh(void)758 virtual MyMesh *getMesh(void) { return NULL; } 759 hasTwoSides(void)760 virtual bool hasTwoSides(void) { return false; } isDoubleSided(void)761 virtual bool isDoubleSided(void) { return false; } toggleDoubleSided(void)762 virtual void toggleDoubleSided(void) {} getConvexField()763 virtual int getConvexField() { return -1; } getNormalField()764 virtual int getNormalField() { return -1; } getTexCoordField()765 virtual int getTexCoordField() { return -1; } getSolidField()766 virtual int getSolidField() { return -1; } flipSide(void)767 virtual void flipSide(void) {} 768 startSetMultiHandles()769 virtual void startSetMultiHandles() {} endSetMultiHandles()770 virtual void endSetMultiHandles() {} validHandle(int handle)771 virtual bool validHandle(int handle) { return true; } checkHandle(int handle)772 virtual bool checkHandle(int handle) { return true; } getMaxHandle(void)773 virtual int getMaxHandle(void) { return 0; } getHandle(int handle,int * constraint,int * field)774 virtual Vec3f getHandle(int handle, int *constraint, int *field) 775 { 776 *field = -1; 777 return Vec3f(0.0f, 0.0f, 0.0f); 778 } setHandle(int,const Vec3f &)779 virtual void setHandle(int /* handle */, const Vec3f & /* v */) {} 780 getNumVertex(void)781 virtual int getNumVertex(void) { return 0; } getVertex(int i)782 virtual Vec3f getVertex(int i) { return Vec3f(); } getValidVertex(void)783 virtual bool getValidVertex(void) { return false; } 784 785 virtual void sendEvent(int eventOut, double timestamp, 786 FieldValue *value); 787 virtual void receiveEvent(int eventIn, double timestamp, 788 FieldValue *value); 789 790 int writeCSendEvent(int f, int indent, int languageFlag, 791 EventIn *target, EventOut *source, 792 Node *sNode); 793 794 int writeCCopyEvent(int f, int indent, int languageFlag, 795 EventOut *target, EventOut *source, 796 Node *sNode); 797 798 int writeCCopyEvent(int f, int indent, int languageFlag, 799 EventIn *target, EventIn *source, 800 Node *sNode); 801 802 int writeCDowithEvent(int f, int indent, int languageFlag, 803 const char *target, const char *source, 804 Node *sNode, bool isArray, int type); 805 isInterpolator()806 virtual bool isInterpolator() { return false; } 807 hasProtoNodes(void)808 virtual bool hasProtoNodes(void) { return false; } 809 hasControlPoints(void)810 virtual bool hasControlPoints(void) { return false; } 811 812 //nurbs conversion virtual toNurbs()813 virtual Node *toNurbs() {return NULL;} toNurbs(int nshell,int narea,int narcs,int uDegree,int vDegree)814 virtual Node *toNurbs(int nshell, int narea, int narcs, 815 int uDegree, int vDegree) {return NULL;} toNurbs(int narcslong,int narcslat,int uDegree,int vDegree)816 virtual Node *toNurbs(int narcslong, int narcslat, 817 int uDegree, int vDegree) {return NULL;} toNurbs(int nAreaPoints,int Degree)818 virtual Node *toNurbs(int nAreaPoints, int Degree) {return NULL;} toNurbs(int narcs,int pDegree,float rDegree,int axis)819 virtual Node *toNurbs(int narcs, int pDegree, float rDegree, 820 int axis) {return NULL;} toNurbs(int narcs,int pDegree,float uDegree,Vec3f & P1,Vec3f & P2)821 virtual Node *toNurbs(int narcs, int pDegree, float uDegree, 822 Vec3f &P1, Vec3f &P2) {return NULL;} degreeElevate(int newDegree)823 virtual Node *degreeElevate(int newDegree) {return NULL;} degreeElevate(int newUDegree,int newVDegree)824 virtual Node *degreeElevate(int newUDegree, int newVDegree) 825 {return NULL;} 826 827 virtual int getDegree(bool u = true) { return -1; } elongateNurbs(int handle,float * controlPoints)828 virtual void elongateNurbs(int handle, float *controlPoints) {} 829 830 // mesh conversion virtual 831 virtual Node *toIndexedFaceSet(int meshFlags = MESH_WANT_NORMAL, 832 bool cleanVertices = true, 833 bool triangulate = true) 834 { return NULL; } canConvertToIndexedFaceSet(void)835 virtual bool canConvertToIndexedFaceSet(void) { return false; } shouldConvertToIndexedFaceSet(void)836 virtual bool shouldConvertToIndexedFaceSet(void) 837 { return canConvertToIndexedFaceSet(); } 838 toNurbsTrimmedSurface(void)839 virtual Node *toNurbsTrimmedSurface(void) { return NULL; } 840 841 // indexed triangle set conversion virtual 842 virtual Node *toIndexedTriangleSet(int meshFlags = MESH_TARGET_HAS_CCW) 843 { return NULL; } canConvertToIndexedTriangleSet(void)844 virtual bool canConvertToIndexedTriangleSet(void) { return false; } shouldConvertToIndexedTriangleSet(void)845 virtual bool shouldConvertToIndexedTriangleSet(void) 846 { return canConvertToIndexedTriangleSet(); } 847 848 // triangle set conversion virtual 849 virtual Node *toTriangleSet(int meshFlags = MESH_TARGET_HAS_CCW) 850 { return NULL; } canConvertToTriangleSet(void)851 virtual bool canConvertToTriangleSet(void) { return false; } shouldConvertToTriangleSet(void)852 virtual bool shouldConvertToTriangleSet(void) 853 { return canConvertToTriangleSet(); } 854 canSimpleTriangulate(void)855 virtual bool canSimpleTriangulate(void) { return false; } simpleTriangulation(void)856 void simpleTriangulation(void) {} 857 858 // chain conversion virtual toIndexedLineSet(void)859 virtual Node *toIndexedLineSet(void) { return NULL; } canConvertToIndexedLineSet(void)860 virtual bool canConvertToIndexedLineSet(void) { return false; } 861 862 // extrusion conversion virtual toExtrusion(void)863 virtual Node *toExtrusion(void) { return NULL; } canConvertToExtrusion(void)864 virtual bool canConvertToExtrusion(void) { return false; } 865 866 // convertion to interpolators canConvertToPositionInterpolator(void)867 virtual bool canConvertToPositionInterpolator(void) 868 { return false; } toPositionInterpolator(void)869 virtual Node *toPositionInterpolator(void) 870 { return NULL; } 871 canConvertToOrientationInterpolator(void)872 virtual bool canConvertToOrientationInterpolator(void) 873 { return false; } toOrientationInterpolator(Direction direction)874 virtual Node *toOrientationInterpolator(Direction direction) 875 { return NULL; } 876 canConvertToPositionAndOrientationInterpolators(void)877 virtual bool canConvertToPositionAndOrientationInterpolators(void) 878 { return false; } toPositionAndOrientationInterpolators(NodeList * nodes)879 virtual void toPositionAndOrientationInterpolators(NodeList *nodes) 880 { return; } 881 882 // other conversions toCurveAnimation(void)883 virtual Node *toCurveAnimation(void) { return NULL; } 884 setMeshDirty(void)885 virtual void setMeshDirty(void) {} 886 887 // texture glColorMode textureGlColorMode(void)888 virtual int textureGlColorMode(void) { return -1; } 889 isMeshBasedNode(void)890 virtual bool isMeshBasedNode(void) { return false; } isMeshMorphingNode(void)891 virtual bool isMeshMorphingNode(void) { return false; } isChainBasedNode(void)892 virtual bool isChainBasedNode(void) { return false; } 893 894 // compare content 895 bool isEqual(Node* node); 896 friend bool isEqual(Node* node); 897 898 bool isEqualCopy(Node* node); 899 MyString newEventName(int typeEnum, bool out); 900 901 bool hasRoute(SocketList socketlist); 902 isInvalidChildNode(void)903 virtual bool isInvalidChildNode(void) 904 { 905 // true if node may not be part of a MFNode field 906 // of a other node (or at root of scenegraph) 907 return false; 908 } 909 isProgrammableShaderObject(void)910 virtual bool isProgrammableShaderObject(void) { return false; } 911 isNodeWithAdditionalEvents(void)912 virtual bool isNodeWithAdditionalEvents(void) 913 { return isProgrammableShaderObject(); } 914 915 virtual int getX3dVersion(void) const = 0; isCoverNode(void)916 virtual bool isCoverNode(void) { return false; } hasCoverFields(void)917 virtual bool hasCoverFields(void) { return false; } hasCoverDefault()918 bool hasCoverDefault() { return hasDefault(FF_COVER_ONLY); } isKambiNode(void)919 virtual bool isKambiNode(void) { return false; } hasKambiFields(void)920 virtual bool hasKambiFields(void) { return false; } hasKambiDefault()921 bool hasKambiDefault() { return hasDefault(FF_KAMBI_ONLY); } hasX3dDefault()922 bool hasX3dDefault() { return hasDefault(FF_X3D_ONLY); } 923 bool hasDefault(int flag); 924 setNormalFromMesh(Node * nnormal)925 virtual void setNormalFromMesh(Node *nnormal) {} setTexCoordFromMesh(Node * ntexCoord)926 virtual void setTexCoordFromMesh(Node *ntexCoord) {} 927 isTransparent(void)928 virtual bool isTransparent(void) { return false; } getTransparency(void)929 virtual float getTransparency(void) { return 0; } 930 isFlat(void)931 virtual bool isFlat(void) { return false; } 932 getCoordinateNode()933 virtual NodeCoordinate *getCoordinateNode() { return NULL; } 934 getColorNode()935 virtual NodeColor *getColorNode() { return NULL; } hasColor(void)936 virtual bool hasColor(void) { return false; } hasColorRGBA(void)937 virtual bool hasColorRGBA(void) { return false; } getColorRGBANode()938 virtual NodeColorRGBA *getColorRGBANode() { return NULL; } 939 hasX3domOnOutputChange(void)940 virtual bool hasX3domOnOutputChange(void) { return false; } hasX3domOnclick(void)941 virtual bool hasX3domOnclick(void) { return false; } 942 943 void handleIs(void); 944 Node *getIsNode(int nodeIndex); setScene(Scene * scene)945 void setScene(Scene *scene) { m_scene = scene; } isInsideProto(void)946 bool isInsideProto(void) 947 { return m_insideProto != NULL; } setOutsideProto(Proto * proto)948 void setOutsideProto(Proto *proto) { m_insideProto = proto; } getOutsideProto(void)949 Proto *getOutsideProto(void) { return m_insideProto; } 950 getNodePROTO(void)951 NodePROTO *getNodePROTO(void) { return m_nodePROTO; } 952 953 void removeChildren(void); 954 bool isDefault(int field) const; 955 bool isDefaultAngle(int field) const; 956 bool hasOutput(const char* routename) const; 957 bool hasOutputs(void); 958 bool hasOutputsOrIs(void); 959 bool hasInput(const char* routename) const; 960 bool hasInputs(void); 961 bool hasInputsOrIs(void); 962 bool hasInputsIs(void); 963 int writeRoutes(int f, int indent) const; 964 void removeRoutes(void); 965 966 void generateTreeLabel(void); 967 968 void setDefault(void); canMoveTo(int direction)969 virtual bool canMoveTo(int direction) { return false; } 970 971 virtual Node *convert2X3d(void); 972 virtual Node *convert2Vrml(void); 973 setupFinished(void)974 virtual void setupFinished(void) {} 975 getChildrenField(void)976 virtual int getChildrenField(void) const { return -1; } 977 978 virtual const char *getVariableName(void); 979 void setVariableName(const char *name); unSetVariableName(void)980 void unSetVariableName(void) { m_variableName = ""; } 981 982 const char *getClassName(void); 983 isDynamicFieldsNode(void)984 virtual bool isDynamicFieldsNode(void) { return false; } 985 986 virtual bool isPROTO(void) const; 987 getLoadedNodes(void)988 virtual NodeList *getLoadedNodes(void) { return NULL; } 989 990 virtual int repairField(int field) const; 991 virtual int translateField(int field) const; 992 993 int writeCVariable(int f, int languageFlag); getCounter4SceneTreeView(void)994 int getCounter4SceneTreeView(void) 995 { return m_counter4SceneTreeView; } addCounter4SceneTreeView(void)996 void addCounter4SceneTreeView(void) 997 { m_counter4SceneTreeView++; } setCounter4SceneTreeViewToZero(void)998 void setCounter4SceneTreeViewToZero(void ) 999 { m_counter4SceneTreeView = 0; } 1000 long getId(void); 1001 void setId(long id); 1002 1003 // for Node*Viewpoint getPosition()1004 virtual Vec3d getPosition() const { return Vec3d(); } getOrientation()1005 virtual Quaternion getOrientation() const { return Quaternion(); } setPosition(const Vec3d & pos)1006 virtual void setPosition(const Vec3d &pos) {} setOrientation(const Quaternion & quat)1007 virtual void setOrientation(const Quaternion &quat) {} fov()1008 virtual SFFloat *fov() { return NULL; }; getMatrix(float * matrix)1009 virtual void getMatrix(float* matrix) {} 1010 void apply(bool useStereo = false) {} getWritten(void)1011 bool getWritten(void) { return m_written; } setWritten(bool flag)1012 void setWritten(bool flag) { m_written = flag; } 1013 isInAlreadyWrittenEventOuts(int eventOut,int numOutput,Node * protoNode)1014 bool isInAlreadyWrittenEventOuts(int eventOut, 1015 int numOutput, 1016 Node *protoNode) 1017 { 1018 for (long i = 0; 1019 i < m_alreadyWrittenEventOuts.size(); i++) 1020 if ((m_alreadyWrittenEventOuts[i].eventOut 1021 == eventOut) && 1022 (m_alreadyWrittenEventOuts[i].numOutput 1023 == numOutput) && 1024 (m_alreadyWrittenEventOuts[i].protoNode 1025 == protoNode) 1026 ) 1027 return true; 1028 return false; 1029 } 1030 appendToAlreadyWrittenEventOuts(int eventOut,int numOutput,Node * protoNode)1031 void appendToAlreadyWrittenEventOuts(int eventOut, 1032 int numOutput, 1033 Node *protoNode) 1034 { 1035 EventOutData data; 1036 data.eventOut = eventOut; 1037 data.numOutput = numOutput; 1038 data.protoNode = protoNode; 1039 m_alreadyWrittenEventOuts.append(data); 1040 } removeAlreadyWrittenEventOuts(void)1041 void removeAlreadyWrittenEventOuts(void) 1042 { m_alreadyWrittenEventOuts.resize(0); } 1043 1044 bool hasRouteForProcessEvent(void); 1045 getX3domId(void)1046 const char * getX3domId(void) 1047 { 1048 if (strlen(m_x3domId) > 0) 1049 return m_x3domId; 1050 return m_name; 1051 } setX3domId(const char * id)1052 void setX3domId(const char *id) { m_x3domId = strdup(id); } setX3domOnOutputChange(const char * function)1053 void setX3domOnOutputChange(const char *function) 1054 { m_x3domOnOutputChange = strdup(function); } setX3domOnClick(const char * function)1055 void setX3domOnClick(const char *function) 1056 { m_x3domOnClick = strdup(function); } 1057 1058 protected: 1059 const char *searchIsName(int i, int type); 1060 1061 int writeIs(int f, int indent, 1062 const char *name, const char * isName); 1063 virtual int writeFields(int f, int indent); 1064 int writeField(int f, int indent, int i, 1065 bool script = false); 1066 int writeEventIn(int f, int indent, int i, 1067 bool eventName = false); 1068 int writeEventOut(int f, int indent, int i, 1069 bool eventName = false); 1070 1071 int writeEventInStr(int f); 1072 int writeEventOutStr(int f); 1073 int writeFieldStr(int f); 1074 int writeExposedFieldStr(int f); 1075 1076 int writeXmlIs(int f, int indent, 1077 const char *name, const char *isName); 1078 int writeXmlProtoInstanceField(int f, int indent, 1079 const char *name, 1080 FieldValue *value); 1081 int writeXmlFields(int f, int indent, int when, 1082 int containerField = -1, 1083 bool avoidUse = false); 1084 int writeXmlField(int f, int indent, int i, int when, 1085 bool script = false, 1086 int containerField = -1, 1087 bool avoidUse = false); 1088 int writeXmlEventIn(int f, int indent, int i, int when, 1089 bool eventName = false); 1090 int writeXmlEventOut(int f, int indent, int i, int when, 1091 bool eventName = false); 1092 1093 void addIsElement(Node *node, int field, int elementType, 1094 Proto *origProto, int origField, 1095 int flags = 0); 1096 1097 protected: 1098 Scene *m_scene; 1099 ParentArray m_parents; 1100 MyString m_name; 1101 MyString m_treeLabel; 1102 MyString m_variableName; 1103 NodeArray m_convertedNodes; 1104 int m_refs; 1105 int m_flags; 1106 Proto *m_proto; 1107 FieldValue **m_fields; 1108 int m_numFields; 1109 int m_numEventIns; 1110 int m_numEventOuts; 1111 SocketList *m_inputs; 1112 SocketList *m_outputs; 1113 float m_graphX, m_graphY; 1114 int m_graphWidth, m_graphHeight; 1115 long m_identifier; 1116 long m_identifierCopy; 1117 Proto *m_insideProto; 1118 NodePROTO *m_nodePROTO; 1119 bool m_canDraw; 1120 bool m_isConvertedInCurveAnimaton; 1121 MyArray<EventIn *> m_isEventIns; 1122 MyArray<EventOut *> m_isEventOuts; 1123 MyArray<Field *> m_isFields; 1124 MyArray<ExposedField *> m_isExposedFields; 1125 int m_counter4SceneTreeView; 1126 bool m_written; 1127 MyArray<EventOutData> m_alreadyWrittenEventOuts; 1128 const char * m_x3domId; 1129 const char * m_x3domOnOutputChange; 1130 const char * m_x3domOnClick; 1131 bool m_alreadyConverted; 1132 bool m_writtenCompleteCProcessEvent; 1133 }; 1134 1135 1136 typedef bool (*DoWithNodeCallback)(Node *node, void *data); 1137 typedef bool (*DoWithSimilarBranchCallback)(Node *node, Node *similarNode, 1138 void *data); 1139 typedef void (*DoWithAllElementsCallback)(Element *element, void *data); 1140 1141 class Node : public NodeData 1142 { 1143 public: 1144 Node(Scene *scene, Proto *proto); 1145 Node(const Node &node); 1146 Node(const Node &node, Proto *proto); 1147 1148 virtual ~Node(); 1149 1150 void addParent(Node *parent, int index); 1151 void removeParent(void); hasParent(void)1152 bool hasParent(void) const 1153 { 1154 #ifdef HAVE_NULL_COMPARE 1155 if (this == NULL) 1156 return false; 1157 #endif 1158 if (getNumParents() < 0) 1159 return false; 1160 if (m_geometricParentIndex == -1) 1161 return false; 1162 if (m_geometricParentIndex > getNumParents()) 1163 return false; 1164 return (getParent() != NULL); 1165 } getParent(void)1166 Node *getParent(void) const 1167 { 1168 if (m_parents.size() == 0) 1169 return NULL; 1170 return getParent(m_geometricParentIndex); 1171 } hasParentOrProtoParent(void)1172 bool hasParentOrProtoParent(void) const 1173 { return (getParentOrProtoParent() != NULL); } 1174 Node *getParentOrProtoParent(void) const; getParentField(void)1175 int getParentField(void) const 1176 { return getParentField(m_geometricParentIndex); } 1177 getParent(int index)1178 Node *getParent(int index) const 1179 { 1180 return index == -1 ? NULL : m_parents[index].m_node; 1181 } getParentField(int index)1182 int getParentField(int index) const 1183 { 1184 return index == -1 ? -1 : m_parents[index].m_field; 1185 } 1186 1187 int getParentFieldOrProtoParentField(void) const; 1188 Node *searchParent(int nodeType) const; 1189 Node *searchParentField(int parentfield) const; 1190 int getParentIndex(void) const; 1191 FieldValue *getParentFieldValue(void) const; 1192 void setParentFieldValue(FieldValue *value); 1193 1194 NodeList getParents(void); 1195 1196 bool hasBranchInputs(void); 1197 1198 virtual int write(int filedes, int indent, bool avoidUse = false); 1199 virtual int writeXml(int filedes, int indent, 1200 int containerField = -1, bool avoidUse = false); 1201 1202 bool isInScene(Scene* scene) const; 1203 virtual void addFieldNodeList(int index, NodeList *value, 1204 int containerField = -1); 1205 bool hasAncestor(Node *node) const; getAnimatedNodeField(int field)1206 virtual int getAnimatedNodeField(int field) { return -1; } 1207 virtual bool supportAnimation(void); supportCurveAnimation(void)1208 virtual bool supportCurveAnimation(void) { return false; } 1209 bool supportInteraction(void); getColored()1210 virtual Colored *getColored() { return NULL; } getAnimationCommentID(void)1211 virtual int getAnimationCommentID(void) { return -1; } getInteractionCommentID(void)1212 virtual int getInteractionCommentID(void) { return -1; } 1213 virtual bool isInvalidChild(void); hasBoundingBox(void)1214 virtual bool hasBoundingBox(void) { return false; } setBoundingBox(void)1215 virtual void setBoundingBox(void) {} 1216 virtual Vec3f getMinBoundingBox(void); 1217 virtual Vec3f getMaxBoundingBox(void); 1218 Vec3f getBboxSize(void); 1219 Vec3f getBboxCenter(void); flip(int index)1220 virtual void flip(int index) {} swap(int fromTo)1221 virtual void swap(int fromTo) {} 1222 virtual bool showFields(); isEXTERNPROTO(void)1223 virtual bool isEXTERNPROTO(void) { return false; } 1224 // for Hanim applyJoint(int skinNum,MyMesh * mesh,MFVec3f * vertices,Node * parent)1225 virtual void applyJoint(int skinNum, MyMesh *mesh, MFVec3f *vertices, 1226 Node *parent) {} getMatrixDirty(void)1227 virtual bool getMatrixDirty(void) { return false; } 1228 1229 void appendTo(NodeList* nodelist); 1230 void appendComment(Node *node); 1231 1232 void doWithParents(DoWithNodeCallback callback, void *data, 1233 bool searchInRest = true, 1234 bool callSelf = true); 1235 void doWithSiblings(DoWithNodeCallback callback, void *data, 1236 bool searchInRest = true, 1237 bool callSelf = true); 1238 void doWithNextSiblings(DoWithNodeCallback callback, 1239 void *data, bool searchInRest = true, 1240 bool callSelf = true); 1241 1242 bool doWithBranch(DoWithNodeCallback callback, void *data, 1243 bool searchInRest = true, 1244 bool skipBranch = false, 1245 bool skipProto = false, 1246 bool callSelf = true, 1247 bool skipInline = true, 1248 bool searchInConvertedNodes = false); 1249 1250 bool doWithSimilarBranch(DoWithSimilarBranchCallback 1251 callback, Node *similarNode, 1252 void *data); 1253 1254 void doWithAllElements(DoWithAllElementsCallback callback, 1255 void *data); 1256 getParentFlag(int index)1257 parentFlag getParentFlag(int index) const 1258 { return m_parents.get(index).m_parentFlag; } 1259 setParentFlag(int index,parentFlag flag)1260 void setParentFlag(int index, parentFlag flag) 1261 { m_parents[index].m_parentFlag = flag; } 1262 isFirstUSE(void)1263 bool isFirstUSE(void) 1264 { 1265 if (isPROTO()) 1266 return m_geometricParentIndex == 1; 1267 else 1268 return m_geometricParentIndex == 0; 1269 } isUnused(void)1270 bool isUnused(void) { return m_geometricParentIndex == -1; } getIsUse(void)1271 bool getIsUse(void) { return m_isUse; } setIsUse(bool flag)1272 void setIsUse(bool flag) { m_isUse = flag; } 1273 1274 void copyChildrenTo(Node *copyedNode, 1275 bool copyNonNodes = false); 1276 void copyOutputsTo(Node *copyedNode); 1277 void copyInputsTo(Node *copyedNode); 1278 1279 int getSiblingIndex(void); 1280 int getPrevSiblingIndex(void); 1281 int getNextSiblingIndex(void); 1282 1283 Node *getPrevSibling(void); 1284 Node *getNextSibling(void); 1285 isJoint(void)1286 virtual bool isJoint(void) { return false; } isHumanoid(void)1287 virtual bool isHumanoid(void) { return false; } 1288 1289 virtual int writeC(int filedes, int languageFlag); 1290 int writeCDataAsFunctions(int filedes, int languageFlag, 1291 bool cont = false); 1292 int writeCDataAsClasses(int filedes, int languageFlag); 1293 int writeCDataFunction(int filedes, int languageFlag, 1294 bool forward, bool cont = false); 1295 int writeCDataFunctionFields(int filedes, int languageFlag, 1296 bool forward, bool cont); 1297 int writeCElement(int f, int elementType, int i, 1298 int languageFlag, bool nodeFlag); 1299 int writeCElementFunction(int f, int elementType, 1300 int i, int languageFlag, 1301 bool nodeFlag, bool cont = false); 1302 int writeCElementClass(int f, int elementType, int i, 1303 int languageFlag, bool nodeFlag); 1304 int writeCAndFollowRoutes(int f, int indent, 1305 int languageFlag, 1306 bool writeSensorNodes, 1307 const char *eventName); 1308 int writeCProcessEvent(int f, int indent, int languageFlag, 1309 const char *eventName); 1310 int writeCProcessEventCallback(int f, int languageFlag); writeCDynamicNodeCallback(int f,int languageFlag)1311 virtual int writeCDynamicNodeCallback(int f, int languageFlag) 1312 { return 0; } 1313 int writeCInstallDynamicNodeCallback(int f, int languageFlag, 1314 Proto *proto); 1315 int writeCGetParent(int filedes, int languageFlag); 1316 writeCWarning(void)1317 virtual void writeCWarning(void) {} 1318 1319 virtual bool canWriteCattGeo(); 1320 virtual int writeCattGeo(int filedes, int indent); getGeometricParentIndex(void)1321 int getGeometricParentIndex(void) const 1322 { return m_geometricParentIndex; } 1323 Path *getPath() const; 1324 bool isDeepInsideProto(void); 1325 buildExportMaterialName(const char * name)1326 virtual char *buildExportMaterialName(const char *name) 1327 { return mystrdup(name); } 1328 char* getExportMaterialName(const char *defaultName); 1329 1330 int getContainerField(void); 1331 void setContainerField(int containerField); 1332 getProtoParent(void)1333 Node *getProtoParent(void) { return m_protoParent; } setProtoParent(Node * n)1334 void setProtoParent(Node *n) { m_protoParent = n; } 1335 void setNodePROTO(NodePROTO *node); 1336 NodeHAnimHumanoid *getHumanoid(); 1337 virtual Node *getIndexedFaceSet(void); getColorPerVertex(void)1338 bool getColorPerVertex(void) { return false; } 1339 virtual void setAlreadyConverted(void); getAlreadyConverted(void)1340 virtual bool getAlreadyConverted(void) { return m_alreadyConverted; } 1341 bool isCWriteable(); 1342 1343 protected: 1344 int m_geometricParentIndex; 1345 NodeList *m_commentsList; 1346 int m_numberCDataFunctions; 1347 int m_containerField; 1348 Node *m_protoParent; 1349 bool m_isUse; 1350 }; 1351 1352