home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / inventor / noodle / WorldInfo.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  10.5 KB  |  410 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  |   Classes:
  19.  |    WorldInfo
  20.  |
  21.  |   Author(s): Paul Isaacs
  22.  |
  23.  */
  24.  
  25.  
  26. #include <stdio.h>
  27. #include <Inventor/SbLinear.h>
  28. #include <Inventor/SoDB.h>
  29. #include <Inventor/SoLists.h>
  30. #include <Inventor/SbViewportRegion.h>
  31. #include <Inventor/SoPickedPoint.h>
  32.  
  33. #include <Inventor/actions/SoGetBoundingBoxAction.h>
  34. #include <Inventor/actions/SoSearchAction.h>
  35. #include <Inventor/manips/SoHandleBoxManip.h>
  36. #include <Inventor/nodes/SoSelection.h>
  37. #include <Inventor/nodes/SoSeparator.h>
  38. #include <Inventor/errors/SoDebugError.h>
  39.  
  40. #include "WorldInfo.h"
  41. #include "GeneralizedCylinder.h"
  42.  
  43. WorldInfo::WorldInfo()
  44. {
  45.     // Make worldRoot
  46.     worldRoot = new SoSeparator;
  47.     worldRoot->ref();
  48.  
  49.     // Add selection node.
  50.  
  51.     selector = new SoSelection;
  52.     worldRoot->addChild(selector);
  53.     selector->addSelectionCallback( &WorldInfo::selectionCB, this );
  54.     selector->addDeselectionCallback( &WorldInfo::deselectionCB, this );
  55.     selector->setPickFilterCallback( &WorldInfo::pickFilterCB, this );
  56.  
  57.     // Put sceneRoot under selector
  58.     sceneRoot = new SoSeparator;
  59.     selector->addChild( sceneRoot );
  60.  
  61.     // Create the deletedNoodles list. We store them so they can be un-deleted.
  62.     deletedNoodles = new SoNodeList;
  63.     
  64.     // This piece will be dragged in z whenever the activePlane moves.
  65.         currentNoodle = NULL;
  66.  
  67.     // Initialize other variables.
  68.     fileName = NULL;
  69.  
  70.     manipType = SoTransform::getClassTypeId();
  71. }
  72.  
  73. WorldInfo::~WorldInfo()
  74. {
  75.     if ( worldRoot ) worldRoot->unref();
  76.     if ( deletedNoodles ) delete deletedNoodles;
  77. }
  78.  
  79. /////////////////////////////////////////////////////////////////////
  80. // Set the type of manipulator being used to move selected noodles.
  81. // Then install one in each selected noodle.
  82. //
  83. void    
  84. WorldInfo::setManipType( SoType newType )
  85. { 
  86.     if ( newType == manipType)
  87.     return;
  88.  
  89.     if ( ! newType.isDerivedFrom( SoTransform::getClassTypeId() ))
  90.     return;
  91.  
  92.     manipType = newType; 
  93.  
  94.     // Get all selections; replace their transforms with the new type.
  95.     const SoPathList *pl = selector->getList();
  96.     for (int i = 0; i < selector->getNumSelected(); i++ ) {
  97.  
  98.     SoNode *t = (*pl)[i]->getTail();
  99.     if (t->isOfType(GeneralizedCylinder::getClassTypeId()))
  100.         ((GeneralizedCylinder *)t)->changeTransformType(newType);
  101.     }
  102. }
  103.  
  104. /////////////////////////////////////////////////////////////////////
  105. // Returns a copy of the scene with all noodles replaced by subgraphs
  106. // of standard inventor nodes.
  107. SoSeparator *
  108. WorldInfo::getVanillaSceneCopy()
  109. {
  110.     if (sceneRoot == NULL)
  111.     return NULL;
  112.  
  113.     SoSeparator *myCopy = (SoSeparator *) sceneRoot->copy();
  114.     myCopy->ref();
  115.  
  116.     // Replace every GeneralizedCylinder  in the copy with just the 
  117.     // data that draws, removing the nodekit.
  118.     SoSearchAction *sa = new SoSearchAction;
  119.     sa->setType( GeneralizedCylinder::getClassTypeId() );
  120.     sa->setInterest( SoSearchAction::ALL );
  121.     sa->apply( myCopy );
  122.     SoPathList *genCylPaths = &(sa->getPaths());
  123.     SoFullPath *myPath;
  124.     SoNode              *myParent;
  125.     GeneralizedCylinder *gc;
  126.     SoGroup             *parentGroup;
  127.  
  128.     for ( int i = 0; i < genCylPaths->getLength(); i++ ) {
  129.     myPath = (SoFullPath *) (*genCylPaths)[i];
  130.     myParent = myPath->getNode( myPath->getLength() - 2 );
  131.     gc = (GeneralizedCylinder *) myPath->getTail();
  132.     if ( myParent->isOfType( SoGroup::getClassTypeId() ) == FALSE ) {
  133.         fprintf(stderr,"Error converting scene to vanilla. Found a \n");
  134.         fprintf(stderr,"non-group parent of the generalized cyliinder\n");
  135.         break;
  136.     }
  137.     parentGroup = (SoGroup *) myParent;
  138.     SoSeparator *vanillaObject = gc->makeVanillaVersion();
  139.     parentGroup->replaceChild( gc, vanillaObject );
  140.     }
  141.  
  142.     // Delete the search action BEFORE unrefNodelete. This takes
  143.     // count down to 1.
  144.     delete sa;
  145.  
  146.     // Take count from 1 to 0
  147.     myCopy->unrefNoDelete();
  148.  
  149.     return myCopy;
  150. }
  151.  
  152. void 
  153. WorldInfo::setScene( SoSeparator *newScene )
  154. {
  155.     if (newScene == sceneRoot)
  156.     return;
  157.  
  158.     // Deselect everything.
  159.     selector->deselectAll();
  160.  
  161.     // Always have at least an empty separator in the scene.
  162.     if (newScene == NULL)
  163.     newScene = new SoSeparator;
  164.  
  165.     if (sceneRoot == NULL) {
  166. #ifdef DEBUG
  167.     SoDebugError::post("WorldInfo::setScene", "old sceneRoot is NULL");
  168. #endif
  169.     selector->insertChild( newScene, 0 );
  170.     }
  171.     else
  172.         selector->replaceChild( sceneRoot, newScene );
  173.  
  174.     sceneRoot = newScene;
  175.  
  176.     // Now, select the first noodle in the scene
  177.     setFirstNoodleCurrent();
  178. }
  179.  
  180. SbBool
  181. WorldInfo::isSceneEmpty()
  182. {
  183.     if (sceneRoot == NULL) {
  184. #ifdef DEBUG
  185.     SoDebugError::post("WorldInfo::setScene", "old sceneRoot is NULL");
  186. #endif
  187.     return TRUE;
  188.     }
  189.     else 
  190.     return ( sceneRoot->getNumChildren() == 0);
  191. }
  192.  
  193. void 
  194. WorldInfo::setFileName( char *newFileName )
  195. {
  196.     if (newFileName == NULL)
  197.     fileName = NULL;
  198.     else
  199.     fileName = strdup( newFileName );
  200. }
  201.  
  202. void 
  203. WorldInfo::addNoodle( GeneralizedCylinder *newNoodle )
  204. {
  205.     if (newNoodle == NULL)
  206.     return;
  207.     sceneRoot->addChild( newNoodle );
  208. }
  209.  
  210. void 
  211. WorldInfo::deleteNoodle( GeneralizedCylinder *victim )
  212. {
  213.     // See if victim is in the selection list...
  214.     // We'd prefer to delete based on selection path, if possible, since we
  215.     // can then deselect.
  216.     SoFullPath *victimPath = NULL;
  217.     for (int i = 0; i < selector->getNumSelected(); i++ ) {
  218.     if ( ((SoNodeKitPath *)selector->getPath(i))->getTail() == victim ) {
  219.         victimPath = (SoFullPath *) selector->getPath(i);
  220.         victimPath->ref();
  221.         break;
  222.     }
  223.     }
  224.     if (victimPath) {
  225.         // deselect old one if it is selected...
  226.     selector->deselect(victimPath);
  227.     }
  228.     else {
  229.         // If it wasn't a selection, get a path to it...
  230.     SoSearchAction sa;
  231.     sa.setNode( victim );
  232.     sa.setInterest( SoSearchAction::FIRST );
  233.         SbBool wasSearchingKits = SoBaseKit::isSearchingChildren();
  234.         SoBaseKit::setSearchingChildren(TRUE);
  235.     sa.apply( selector );
  236.         SoBaseKit::setSearchingChildren(wasSearchingKits);
  237.     victimPath = (SoFullPath *) sa.getPath();
  238.     if (victimPath)
  239.         victimPath->ref();
  240.     }
  241.  
  242.     if ( ! victimPath )
  243.     return;
  244.  
  245.     // Remove piece from parent.
  246.     if (victimPath != NULL) {
  247.     // Get index of victim in the path...
  248.     for (int objInd = victimPath->getLength() - 1; objInd >= 0; objInd --) {
  249.         if ( victimPath->getNode(objInd) == victim )
  250.         break;
  251.     }
  252.     SoNode *parent = NULL;
  253.     SoType bkt = SoBaseKit::getClassTypeId();
  254.     // Remove victim from its parent.
  255.     // For parent, if there's a nodekit above victim, use that first kit.
  256.         for (int pInd = objInd - 1; pInd >= 0; pInd --) {
  257.         if (victimPath->getNode(pInd)->isOfType( bkt ) ) {
  258.             parent = victimPath->getNode(pInd);
  259.             SoBaseKit *k = (SoBaseKit *)parent;
  260.             k->setPart( k->getPartString(victim), NULL );
  261.             break;
  262.         }
  263.         }
  264.     // Otherwise, use the first node above victim.
  265.         if ( parent == NULL ) {
  266.         parent = victimPath->getNodeFromTail( 1 );
  267.         if (parent->isOfType( SoGroup::getClassTypeId() ))
  268.             ((SoGroup *)parent)->removeChild( victim );
  269.         }
  270.  
  271.     }
  272.     victimPath->unref();
  273. }
  274.  
  275.  
  276. void 
  277. WorldInfo::deleteCurrentNoodle()
  278. {
  279.     if (currentNoodle == NULL)
  280.     return;
  281.  
  282.     currentNoodle->ref();
  283.     deleteNoodle( currentNoodle );
  284.     deletedNoodles->append( currentNoodle );
  285.     currentNoodle->unref();
  286. }
  287.  
  288. GeneralizedCylinder * 
  289. WorldInfo::undeleteNoodle()
  290. {
  291.     int num = deletedNoodles->getLength();
  292.     if ( num <= 0)
  293.     return NULL;
  294.  
  295.     GeneralizedCylinder *theNoodle 
  296.     = (GeneralizedCylinder *) (*deletedNoodles)[num - 1];
  297.  
  298.     theNoodle->ref();
  299.  
  300.     addNoodle( theNoodle );
  301.  
  302.     // Since we're undeleting the noodle, make it the only selection.
  303.     selector->deselectAll();
  304.     selector->select( theNoodle );
  305.  
  306.     setCurrentNoodle( theNoodle );
  307.  
  308.     theNoodle->unrefNoDelete();
  309.  
  310.     deletedNoodles->remove( num - 1);
  311.  
  312.     return theNoodle;
  313. }
  314.  
  315. GeneralizedCylinder *
  316. WorldInfo::setFirstNoodleCurrent()
  317. {
  318.     if (sceneRoot == NULL)
  319.     return NULL;
  320.  
  321.     SoSearchAction sa;
  322.     sa.setType( GeneralizedCylinder::getClassTypeId() );
  323.     sa.apply( sceneRoot );
  324.     SoPath *pathToFirst = sa.getPath();
  325.     if (pathToFirst == NULL)
  326.     return NULL;
  327.  
  328.     GeneralizedCylinder *first = (GeneralizedCylinder *) pathToFirst->getTail();
  329.  
  330.     // Since we're undeleting the noodle, make it the only selection.
  331.     selector->deselectAll();
  332.     selector->select( first );
  333.  
  334.     setCurrentNoodle( first );
  335.  
  336.     return first;
  337. }
  338.  
  339. GeneralizedCylinder * 
  340. WorldInfo::addNewNoodle()
  341. {
  342.     GeneralizedCylinder *newOne = new GeneralizedCylinder;
  343.     newOne->ref();
  344.  
  345.     addNoodle( newOne );
  346.  
  347.     // Since we're adding a new noodle, make it the only selection.
  348.     selector->deselectAll();
  349.     selector->select( newOne );
  350.  
  351.     setCurrentNoodle( newOne );
  352.     newOne->unrefNoDelete();
  353.  
  354.     return newOne;
  355. }
  356.  
  357. void
  358. WorldInfo::setCurrentNoodle( GeneralizedCylinder *newNoodle )
  359. {
  360.     currentNoodle = newNoodle;
  361.  
  362.     // Add a manipulator if necessary...
  363.     if (currentNoodle)
  364.     currentNoodle->changeTransformType( getManipType() );
  365. }
  366.  
  367. void
  368. WorldInfo::selectionCB(void *userData, SoPath *selectPath)
  369. {
  370.     // Return if pickFilter truncated path down to nothing.
  371.     if (selectPath->getLength() == 0)
  372.     return;
  373.  
  374.     WorldInfo *myself = (WorldInfo *) userData;
  375.  
  376.     SoNodeKitPath *nkPath = (SoNodeKitPath *) selectPath;
  377.     GeneralizedCylinder *g = (GeneralizedCylinder *) nkPath->getTail();
  378.  
  379.     myself->setCurrentNoodle( g );
  380. }
  381.  
  382. void
  383. WorldInfo::deselectionCB(void *, SoPath *deselectPath)
  384. {
  385.     if (deselectPath->getLength() == 0)
  386.     return;
  387.  
  388.     SoNodeKitPath *nkPath = (SoNodeKitPath *) deselectPath;
  389.     GeneralizedCylinder *g = (GeneralizedCylinder *) nkPath->getTail();
  390.  
  391.     g->changeTransformType( SoTransform::getClassTypeId() );
  392. }
  393.  
  394. SoPath *
  395. WorldInfo::pickFilterCB(void *data, const SoPickedPoint *pick )
  396. {
  397.     WorldInfo *myself = (WorldInfo *) data;
  398.  
  399.     SoPath *filteredPath = NULL;
  400.     SoFullPath *fullP = (SoFullPath *) pick->getPath();
  401.  
  402.     // Go up the path, and keep popping nodes until the tail is a
  403.     // Generalized Cylinder kit...
  404.     while ( fullP->getLength() > 0 &&
  405.     ! fullP->getTail()->isOfType( GeneralizedCylinder::getClassTypeId() ) )
  406.     fullP->pop();
  407.  
  408.     return fullP;
  409. }
  410.