home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win / sieciowe / oiv_demo.lzh / disk2 / DATA.2 / include / Ivf / Viewers / SoSceneViewer.h < prev    next >
C/C++ Source or Header  |  1995-07-11  |  19KB  |  584 lines
  1. //  -*- C++ -*-
  2.  
  3. /*
  4.  * Copyright (C) 1990-93   Silicon Graphics, Inc.
  5.  *
  6.  _______________________________________________________________________
  7.  ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
  8.  |
  9.  |   $Revision: 1.4 $
  10.  |
  11.  |   Classes    : SoSceneViewer
  12.  |
  13.  |   Author(s)    : Thad Beier, Alain Dumesny, David Mott, Paul Isaacs
  14.  |
  15.  ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
  16.  _______________________________________________________________________
  17.  */
  18.  
  19. #ifndef  _SCENE_VIEWER_
  20. #define  _SCENE_VIEWER_
  21.  
  22. #ifndef WIN32
  23. #include <X11/Intrinsic.h>
  24. #include <Xm/Xm.h>
  25. #include <Xm/RowColumn.h>
  26. #endif
  27.  
  28. #include <Inventor/nodes/SoNode.h>
  29. #include <Inventor/SbPList.h>
  30. #include <Inventor/nodes/SoPerspectiveCamera.h>
  31. #include <Inventor/actions/SoGLRenderAction.h>    // transparency levels
  32. #include <Inventor/actions/SoCallbackAction.h>
  33. #include <Inventor/Win/viewers/SoWinFullViewer.h>
  34.  
  35. // components
  36. #ifdef WIN32
  37. #define MyColorEditor SoWinColorEditor
  38. // this can be changed below with setFirstLightMenuId
  39. #define ID_SV_FIRST_LIGHT    16386
  40. #endif
  41.  
  42. class    MyColorEditor;
  43. class    SoWinMaterialEditor;
  44.  
  45. #ifdef NOTYET
  46. class    SoWinPrintDialog;
  47. class    SoWinTransformSliderSet;
  48. #endif
  49.  
  50. class    SoWinClipboard;
  51. class    SoWinDirectionalLightEditor;
  52.  
  53. // interaction
  54. class    SoBoxHighlightRenderAction;
  55. class    SoSelection;
  56. class    SoPickedPoint;
  57.  
  58. // nodes
  59. class    SoDirectionalLight;
  60. class    SoEnvironment;
  61. class    SoGroup;
  62. class    SoLabel;
  63. class    SoMaterial;
  64. class    SoSceneViewer;
  65. class   SoSwitch;
  66. class    SoLight;
  67. class    SoTransform;
  68.  
  69. // misc.
  70. class    SvManipList;
  71.  
  72. enum SvEViewer {
  73.     SV_VWR_EXAMINER = 0, 
  74.     SV_VWR_FLY, 
  75.     SV_VWR_WALK, 
  76.     SV_VWR_PLANE, 
  77. };
  78.  
  79. enum SvEManipMode {
  80.     SV_NONE,                         // None
  81.     SV_TRACKBALL,                    // Trackball manip
  82.     SV_HANDLEBOX,                    // Handlebox manip
  83.     SV_JACK,                         // Jack manip
  84.     SV_CENTERBALL,                   // Centerball manip
  85.     SV_XFBOX,                        // TransformBox manip
  86.     SV_TABBOX                        // TabBox manip
  87. };
  88.  
  89. #ifdef WIN32
  90.  
  91. #define SvMenuAction(p,action) \
  92. { \
  93.     SoSceneViewerData data ; \
  94.         data.classPt = pSV ; \
  95.         data.id = action ; \
  96.         data.widget = NULL ; \
  97.         SoSceneViewer::processTopbarEvent( \
  98.                         pSV, \
  99.                         &data, \
  100.                         NULL \
  101.                     ) ; \
  102. }
  103.  
  104. struct SoSceneViewerData {
  105.     int id;
  106.     SoSceneViewer *classPt;
  107.     Widget widget;
  108. };
  109. #else
  110. struct    SoSceneViewerData;
  111. #endif
  112. struct    SvLightData;
  113.  
  114. //////////////////////////////////////////////////////////////////////////////
  115. //
  116. //  Class: SoSceneViewer
  117. //
  118. //      The SceneViewer component lets you select between different viewers
  119. //  (Examiner, Navigator,..) and lets you perform  some simple attribute
  120. //  assignment, and some manipulation of data.
  121. //
  122. //////////////////////////////////////////////////////////////////////////////
  123.  
  124. class SoSceneViewer : public SoWinComponent {
  125.  
  126.   public:    
  127.     // Constructor:
  128.     // envFile is the environment file to use. This is where the camera,
  129.     // environment node, and lights are found. 
  130.     // Passing NULL means use the default environment.
  131.     //
  132.     // Save will save all the children of root, not including root itself.
  133.     // Save Environment will save the lights and camera environment into envFile
  134.     //
  135.     SoSceneViewer(
  136.     Widget parent = NULL, 
  137.     const char *name = NULL, 
  138.     SbBool buildInsideParent = TRUE, 
  139.     SoSelection *root = NULL,
  140.     const char *envFile = NULL);
  141.     ~SoSceneViewer();
  142.  
  143. #ifdef WIN32
  144.     SoEXTENDER
  145.     SoSceneViewer(
  146.         Widget parent,
  147.         const char *name, 
  148.         SbBool buildInsideParent, 
  149.         SoSelection *root,
  150.         const char *envFile, 
  151.         SbBool buildNow);
  152.  
  153.     static void            processTopbarEvent(Widget, SoSceneViewerData *,
  154.                                               XmAnyCallbackStruct *);
  155.  
  156.     void realizeWidget() ;
  157. #endif
  158.  
  159.  
  160.   protected:  
  161.  
  162. #ifdef WIN32
  163.     SbBool realized ;
  164. #endif
  165.     // This constructor takes a boolean whether to build the widget now.
  166.     // Subclasses can pass FALSE, then call SoSceneViewer::buildWidget()
  167.     // when they are ready for it to be built.
  168. #ifndef WIN32
  169.     SoEXTENDER
  170.     SoSceneViewer(
  171.         Widget parent,
  172.         const char *name, 
  173.         SbBool buildInsideParent, 
  174.         SoSelection *root,
  175.         const char *envFile, 
  176.         SbBool buildNow);
  177.  
  178. #endif
  179.         
  180.  
  181.   public:
  182.         void        saveViewerSceneGraph(const char *fileName) ;
  183. #ifdef WIN32
  184.     void setFileMode(int nMode) { fileMode = nMode ; } ;
  185.     void    doFileIO(const char *filename);
  186.     SoWinFullViewer *getViewer(int n) {return viewerList[n];} ;
  187.     SoWinFullViewer *getCurrViewer() {return viewerList[whichViewer];} ;
  188.     SvEViewer getWhichViewer() { return whichViewer ; } ;
  189.  
  190.     SoWinMaterialEditor *getMaterialEditor() {return materialEditor;} ;
  191.     SoWinColorEditor *getBackgroundColorEditor() {return backgroundColorEditor;} ;
  192.     SoWinColorEditor *getAmbientColorEditor() {return ambientColorEditor;} ;
  193.     SoWinColorEditor *getColorEditor() {return colorEditor;} ;
  194.     SoWinDirectionalLightEditor *getHeadlightEditor()
  195.                 {return headlightEditor; } ;
  196.  
  197.     SoSelection *getSelection() {return selection;} ;
  198.  
  199.     SvLightData *getHeadlightData() {return headlightData;} ;
  200.  
  201.     void editHeadlight() { editLight(headlightData,TRUE); } ;
  202.  
  203.  
  204.     SvEManipMode getCurrManip() {return curManip;};
  205.  
  206.     SoSeparator     *getSceneGraph() { return sceneGraph;};
  207.     SbBool setSceneGraph(SoNode *node) ;
  208.  
  209.     void setMenuWidget(HMENU hMenu) { menuWidget = hMenu; } ;
  210.     void setLightMenuWidget(HMENU hMenu) { hLightMenu = hMenu; } ;
  211.     void setFirstLightMenuId(ULONG nId) {nFirstLightMenuId = nId; } ;
  212.  
  213.     SbBool        getAAFlag() { return antialiasingFlag;} ;
  214.     SbBool        getFogFlag()  { return fogFlag ; } ;
  215.  
  216. #ifdef NOTDEF
  217.     SbBool onCommand(UINT nId,int nCode) ;
  218. #endif
  219.     SbBool onCommand(WPARAM wParam, LPARAM lParam)  ;
  220.  
  221.         
  222. #endif
  223.     //
  224.     // Camera operation routines
  225.     //
  226.     void    viewAll()        
  227.             { if (currentViewer != NULL) currentViewer->viewAll(); }
  228.     void           viewSelection();
  229.     void    saveHomePosition()  
  230.             { if (currentViewer != NULL) currentViewer->saveHomePosition(); }
  231.     void        setCamera(SoCamera *cam) ;
  232.     // NOTE: because the camera may be changed dynamically (switch between ortho
  233.     // and perspective), the user shouldn't cache the camera.
  234.     SoCamera    *getCamera()        
  235.             { return (currentViewer) ? currentViewer->getCamera() : NULL; }
  236.     
  237.     //
  238.     // Before new data is sent to the viewer, the newData method should
  239.     // be called to disconnect all manipulators and highlights
  240.     //
  241.     void            newData();
  242.     
  243.     // Show/hide the pulldown menu bar (default shown)
  244.     void        showMenu(SbBool onOrOff);
  245.     SbBool        isMenuShown()        { return showMenuFlag; }
  246.     
  247.     // Show/hide the viewer component trims (default shown)
  248.     void                setDecoration(SbBool onOrOff)    
  249.             { if (currentViewer != NULL) currentViewer->setDecoration(onOrOff); }
  250.     SbBool              isDecoration()        
  251.             { return currentViewer != NULL ? currentViewer->isDecoration() : FALSE; }
  252.     
  253.     // Show/hide headlight (default on) and get to the headlight node.
  254.     void                setHeadlight(SbBool onOrOff)    
  255.             { if (currentViewer != NULL) currentViewer->setHeadlight(onOrOff); }
  256.     SbBool              isHeadlight()        
  257.             { return currentViewer != NULL ? currentViewer->isHeadlight() : FALSE; }
  258.     SoDirectionalLight    *getHeadlight()        
  259.             { return currentViewer != NULL ? currentViewer->getHeadlight() : NULL; }
  260.     
  261.     //
  262.     // Sets/gets the current drawing style in the main view - The user
  263.     // can specify the INTERACTIVE draw style (draw style used when 
  264.     // the scene changes) independently from the STILL style.
  265.     //
  266.     // (default VIEW_AS_IS for both STILL and INTERACTIVE)
  267.     //
  268.     void            setDrawStyle(SoWinViewer::DrawType type, 
  269.                 SoWinViewer::DrawStyle style)
  270.                 { currentViewer->setDrawStyle(type, style); }
  271.     SoWinViewer::DrawStyle getDrawStyle(SoWinViewer::DrawType type)
  272.                 { return currentViewer->getDrawStyle(type); }
  273.     
  274.     //
  275.     // Sets/gets the current buffering type in the main view
  276.     // (default BUFFER_INTERACTIVE on Indigo, BUFFER_DOUBLE otherwise)
  277.     //
  278.     void                setBufferingType(SoWinViewer::BufferType type)
  279.                 { currentViewer->setBufferingType(type); }
  280.     SoWinViewer::BufferType getBufferingType()
  281.                 { return currentViewer->getBufferingType(); }
  282.  
  283.     // Turn viewing on/off (Default to on) in the viewers.
  284.     void                setViewing(SbBool onOrOff)  { currentViewer->setViewing(onOrOff); }
  285.     SbBool              isViewing()    { return currentViewer->isViewing(); }
  286.     
  287.     // Set/get the level of transparency type
  288.     void        setTransparencyType(SoGLRenderAction::TransparencyType type)
  289.                     { currentViewer->setTransparencyType(type); }
  290.     SoGLRenderAction::TransparencyType    getTransparencyType()
  291.                     { return currentViewer->getTransparencyType(); }
  292.  
  293.     // returns the current render area widget
  294.     Widget        getRenderAreaWidget()    { return currentViewer->getRenderAreaWidget(); }
  295.     
  296. #ifdef EXPLORER
  297.     // set the EXPLORER user mode callback routine
  298.     void        setUserModeEventCallback(SoWinRenderAreaEventCB *fcn);
  299. #endif /* EXPLORER */
  300.  
  301.  protected:
  302. #ifdef WIN32
  303.     HMENU hLightMenu ;
  304.     ULONG nFirstLightMenuId ;
  305. #endif
  306.     char *envFileName ;
  307.  
  308.  
  309.     // redefine these
  310.     virtual const char *    getDefaultWidgetName() const;
  311.     virtual const char *    getDefaultTitle() const;
  312.     virtual const char *    getDefaultIconTitle() const;
  313.  
  314.     // Support for menus in the popup planes
  315.     Widget        popupWidget;
  316.  
  317.     // Stuff to do after the component has been realized (shown)
  318.     virtual void    afterRealizeHook();
  319.     
  320.  private:
  321.     // Scene graph data
  322.     SoSelection            *selection;            // the same user supplied graph
  323.     SoSeparator     *sceneGraph;        // user supplied scene graph
  324.     
  325.     // Lights, camera, environment!
  326.     SoGroup             *lightsCameraEnvironment;
  327.     SoLabel             *envLabel;
  328.     SoEnvironment       *environment;
  329.     SoGroup             *lightGroup;
  330.     SoCamera             *pCamera ;
  331.     
  332.     void            createLightsCameraEnvironment();
  333.     
  334.     // Selection highlight
  335.     SoBoxHighlightRenderAction *highlightRA;
  336.     
  337.     //
  338.     // Widgets and menus
  339.     //
  340.     
  341.     Widget        mgrWidget;  // our topmost form widget
  342.     Widget        menuWidget; // topbar menu widget
  343.     SbBool        showMenuFlag;
  344. #ifndef WIN32
  345.     SoSceneViewerData    *menuItems; // list of menu items data
  346. #endif
  347.     
  348.     Widget         buildWidget(Widget parent);
  349.     void        buildAndLayoutMenu(Widget parent);
  350.     void        buildAndLayoutViewer(SoWinFullViewer *vwr);
  351.  
  352.     // callback for all menu buttons to perform action
  353. #ifndef WIN32
  354.     static void            processTopbarEvent(Widget, SoSceneViewerData *,
  355.                    XmAnyCallbackStruct *);
  356. #endif
  357.     // callback when a menu is displayed
  358.     static void        menuDisplay(Widget, SoSceneViewerData *, XtPointer);
  359.     
  360.     // this is called after objects are added/deleted or the selection changes
  361.     void        updateCommandAvailability();
  362.     
  363.     //
  364.     // File
  365.     //
  366.     
  367.     // file reading methods
  368.     int        fileMode;
  369.     char    *fileName;
  370.     SbBool    useShowcaseBrowser;
  371.     void    getFileName();
  372. #ifndef WIN32
  373.     void    doFileIO(const char *filename);
  374. #endif
  375.     SbBool        readFile(const char *filename);
  376.     SbBool    writeFile(const char *filename);
  377.     SbBool    readEnvFile(const char *filename);
  378.     SbBool    writeEnvFile(const char *filename);
  379.     void    deleteScene();
  380.     void    save();
  381.  
  382.     // cameras
  383.     void    removeCameras(SoGroup *root);
  384.     // Returns the last scene kit camera in a scene.
  385.     SoCamera    *getLastSceneKitCamera(SoGroup *root);
  386.     // Copies our camera into the last scene kit camera in a scene.
  387.     void        setLastSceneKitCamera(SoGroup *root, SoCamera *theCam);
  388.     // Switches off/ restores camera num settings of scenekits.
  389.     void        switchOffSceneKitCameras(SoGroup *root);
  390.     void        restoreSceneKitCameras(SoGroup *root);
  391.     // Copies from given camera into this viewer's camera, if types match.
  392.     void        setCameraFields( SoCamera *fromCam );
  393.     SbDict      *sceneKitCamNumDict;
  394.     
  395.     // motif vars for file reading/writting
  396. #ifndef WIN32
  397.     Widget        fileDialog;
  398.     static void         fileDialogCB(Widget, SoSceneViewer *,
  399.                                     XmFileSelectionBoxCallbackStruct *);
  400. #endif
  401.         
  402.     // printing vars
  403. #ifdef NOTYET
  404.     SoWinPrintDialog       *printDialog;
  405.     void                print();
  406.     static void         beforePrintCallback(void *uData, SoWinPrintDialog *);
  407.     static void         afterPrintCallback(void *uData, SoWinPrintDialog *);
  408. #endif
  409.  
  410.  
  411.     SbBool        feedbackShown;
  412.     
  413.     void        showAboutDialog();
  414.     
  415.     //
  416.     // Edit
  417.     //
  418.     
  419.     // Select parent, if there is one; select everything.
  420.     void        pickParent();
  421.     void        pickAll();
  422.  
  423.     // for copy and paste
  424.     SoWinClipboard    *clipboard;     // copy/paste 3d data
  425.     void        destroySelectedObjects();
  426.  
  427.     // Paste callback - invoked when paste data transfer is complete
  428.     void                pasteDone(SoPathList *pathList);
  429.     static void        pasteDoneCB(void *userData, SoPathList *pathList);
  430.     
  431.     
  432.     //
  433.     // Viewing
  434.     //
  435.     
  436.     SoWinFullViewer    *viewerList[4];    // list of viewers
  437.     SvEViewer        whichViewer;    // current viewer ID
  438.     SoWinFullViewer    *currentViewer;    // current viewer pt
  439.     
  440.     void                switchToViewer(SvEViewer newViewer);
  441.     
  442.     // Environment: fog, antialiasing
  443.     SbBool        fogFlag;        // Fog on/off
  444.     void        setFog(SbBool onOrOff);    // Turns fog on/off
  445.     SbBool        antialiasingFlag;    // AA-ing on/off
  446.     void        setAntialiasing(SbBool onOrOff); // Turns AA-ing on/off
  447.     
  448.     // Background color
  449.     MyColorEditor       *backgroundColorEditor;
  450.     const SbColor &    getBackgroundColor()    { return currentViewer->getBackgroundColor(); }
  451.     void        editBackgroundColor();    // Invokes color editor on bkg
  452.     static void            backgroundColorCallback(void *userData,
  453.                 const SbColor *color);
  454.     
  455.     //
  456.     // Editors
  457.     //
  458.     
  459.     SbBool              ignoreCallback;
  460.     SoMaterial         *findMaterialForAttach( const SoPath *target );
  461.     SoPath             *findTransformForAttach( const SoPath * target );
  462.     // callback used by Accum state action created by findMaterialForAttach
  463. #ifdef WIN32
  464.     static int findMtlPreTailCB(void *data, 
  465.                         SoCallbackAction *accum,
  466.                         const SoNode *);
  467. #else
  468.  
  469.     static SoCallbackAction::Response findMtlPreTailCB(void *data, 
  470.                         SoCallbackAction *accum,
  471.                         const SoNode *);
  472. #endif
  473.     
  474.     // transform slider set
  475. #ifdef NOTYET
  476.     SoWinTransformSliderSet *transformSliderSet;
  477.     void        createTransformSliderSet();
  478. #endif
  479.  
  480.     // Material editor
  481.     SoWinMaterialEditor      *materialEditor;
  482.     void                createMaterialEditor();
  483.     
  484.     // Color editor
  485.     MyColorEditor       *colorEditor;
  486.     void        createColorEditor();
  487.  
  488.  
  489.     //
  490.     // Manips
  491.     //
  492.     SvEManipMode curManip;
  493.     SbBool       curManipReplaces;
  494.     SvManipList     *maniplist;    // list of selection/manip/xfPath triplets.
  495.  
  496.     // replaces manips with the given type for all selected objects.
  497.     void    replaceAllManips( SvEManipMode manipType );
  498.  
  499.     // attaches a manipulator
  500.     void    attachManip( SvEManipMode manipType, SoPath *p );
  501.     void    attachManipToAll( SvEManipMode manipType );
  502.  
  503.     // detaches a manipulator
  504.     void    detachManip( SoPath *p );
  505.     void    detachManipFromAll();
  506.  
  507.     // Temporarily remove manips for writing, printing, copying, etc.
  508.     // and restore later
  509.     void    removeManips();
  510.     void    restoreManips();
  511.  
  512.     // Callback to adjust size of scale tabs. Used only for SoTabBoxManip
  513.     // Added to viewer as a finishCallback.
  514.     static void SoSceneViewer::adjustScaleTabSizeCB( void *, SoWinViewer *);
  515.  
  516.     //
  517.     // Lighting
  518.     //
  519.     
  520.     SbPList        lightDataList;
  521.     SoWinDirectionalLightEditor *headlightEditor;
  522.     SvLightData        *headlightData;
  523.     void        addLight(SoLight *light);
  524.     SvLightData        *addLightEntry(SoLight *light, SoSwitch *lightSwitch);
  525.     void        addLightMenuEntry(SvLightData *);
  526.     void        turnLightOnOff(SvLightData *data, SbBool flag);
  527.     static void        lightToggleCB(Widget, SvLightData *, void *);
  528.     void        editLight(SvLightData *data, SbBool flag);
  529.     static void        editLightToggleCB(Widget, SvLightData *, void *);
  530.     static void        editLightColorCB(Widget, SvLightData *, void *);
  531.     void        removeLight(SvLightData *);
  532.     static void        removeLightCB(Widget, SvLightData *, void *);
  533.     static void        lightSubmenuDisplay(Widget, SvLightData *, void *);
  534.     void         transferDirectionalLightLocation( SvLightData *data );
  535.  
  536. #ifdef WIN32
  537.     static void headlightEditorCloseCB(void *userData, SoWinComponent *comp) ;
  538.     static void lightColorEditorCloseCB(void *userData, SoWinComponent *comp) ;
  539. #endif    
  540.  
  541.     // vars to make the light manips all the same size
  542.     void        calculateLightManipSize();
  543.     float        lightManipSize;
  544.     SbBool        calculatedLightManipSize;
  545.     
  546.     // temporary remove/add the light manip geometry of the attached manips
  547.     // (used for file writting and printing)
  548.     void        removeAttachedLightManipGeometry();
  549.     void        addAttachedLightManipGeometry();
  550.     
  551.     // Ambient lighting color
  552.     MyColorEditor       *ambientColorEditor;
  553.     void        editAmbientColor();    // Invokes color editor on amb
  554.     static void            ambientColorCallback(void *userData,
  555.                 const SbColor *color);
  556.     
  557.     //
  558.     // Selection
  559.     //
  560.     // manages changes in the selection.
  561.     static void     deselectionCallback(void *userData, SoPath *obj);
  562.     static void     selectionCallback(void *userData, SoPath *obj);
  563.     static SoPath *    pickFilterCB(void *userData, const SoPickedPoint *pick);
  564.     
  565.     //
  566.     // Convenience routines
  567.     //
  568.     static SbBool    isAffectedByTransform( SoNode *node );
  569.     static SbBool    isAffectedByMaterial( SoNode *node );
  570.  
  571. #ifdef EXPLORER
  572.     //
  573.     // user pick function
  574.     //
  575.     SoWinRenderAreaEventCB   *userModeCB;
  576.     void            *userModedata;
  577.     SbBool            userModeFlag;
  578. #endif /* EXPLORER */
  579.  
  580.     void constructorCommon(SoSelection *root, const char *envFile, SbBool buildNow);
  581. };
  582.  
  583. #endif  /* _SCENE_VIEWER_ */
  584.