home *** CD-ROM | disk | FTP | other *** search
/ Late Night VRML 2.0 with Java CD-ROM / code.zip / Ch12 / VrmlScene.java < prev    next >
Text File  |  1997-01-05  |  12KB  |  493 lines
  1. // VRML Generator
  2. // (c) Justin Couch
  3. //
  4. // From Chapter 13: Late Night VRML 2.0 and Java
  5. //
  6. // The class that contains all the information about the VRML scene.
  7. // information is kept as tree structure identical to the VRML tree that it
  8. // represents.
  9. //
  10. // The top level data is stored in a Vector that is created in the
  11.  
  12. import java.io.*;
  13. import java.util.Enumeration;
  14. import java.util.Vector;
  15. import vrml.external.Browser;
  16. import VrmlTypes;
  17. import ui.VrmlTree;
  18. import ui.OutputWindow;
  19. import geometry.*;
  20.  
  21. import exceptions.NoSelectedNodeException;
  22.  
  23. public class VrmlScene
  24. {
  25.     private VrmlTree    screen_list;
  26.     private VrmlRoot    file_root;
  27.     private OutputWindow    vrml_output;
  28.  
  29.     public VrmlScene(OutputWindow vo)
  30.     {
  31.         vrml_output = vo;
  32.  
  33.         // now we need to get the root node from the VRML browser that
  34.         // we will be adding this stuff to.
  35.         file_root = new VrmlRoot();
  36.  
  37.     }
  38.  
  39.     // The kludge method to deal with the static getBrowser method not working
  40.     public VrmlScene(OutputWindow vo, Browser b)
  41.     {
  42.         vrml_output = vo;
  43.  
  44.         // now we need to get the root node from the VRML browser that
  45.         // we will be adding this stuff to.
  46.         file_root = new VrmlRoot(b);
  47.  
  48.     }
  49.  
  50.     // called to complete the setup of the system. This is called by
  51.     // the EditWindow.
  52.     public void setScreenHandler(VrmlTree screen)
  53.     {
  54.         screen_list = screen;
  55.         screen_list.setVrmlRoot(file_root);
  56.     }
  57.  
  58.     // destructor, force clean up of data
  59.     public void finalize()
  60.     {
  61.         screen_list = null;
  62.         file_root = null;
  63.     }
  64.  
  65.     // This is for when it prints directly to the text area.
  66.     public void writeToFile()
  67.     {
  68.         ByteArrayOutputStream os = new ByteArrayOutputStream();
  69.         PrintStream ps = new PrintStream(os);
  70.  
  71.         file_root.writeToFile(ps);
  72.         vrml_output.setContents(os.toString());
  73.  
  74.         try
  75.         {
  76.             ps.close();
  77.             os.close();
  78.         }
  79.         catch(IOException e)
  80.         {
  81.             System.out.println("Error closing output streams");
  82.         }
  83.     }
  84.  
  85.     public void writeToFile(String name)
  86.     {
  87.         PrintStream    fp = null;
  88.  
  89.         // open a file and write to it here.
  90.         if(fp != null)
  91.             file_root.writeToFile(fp);
  92.     }
  93.  
  94.     public void addNode(int node_type, VrmlObject node)
  95.         throws NoSelectedNodeException
  96.     {
  97.         if(node_type <= VrmlTypes.Switch)
  98.             addGroupingNode(node_type, node);
  99.         else if(node_type <= VrmlTypes.WorldInfo)
  100.             addCommonNode(node_type, node);
  101.         else if(node_type <= VrmlTypes.VisibilitySensor)
  102.             addSensorNode(node_type, node);
  103.         else if(node_type <= VrmlTypes.Text)
  104.             addGeometryNode(node_type, node);
  105.         else if(node_type <= VrmlTypes.TextureCoordinate)
  106.             addGeoPropertyNode(node_type, node);
  107.         else if(node_type <= VrmlTypes.TextureTransform)
  108.             addAppearanceNode(node_type, node);
  109.         else if(node_type <= VrmlTypes.ScalarInterpolator)
  110.             addInterpolatorNode(node_type, node);
  111.         else
  112.             addBindableNode(node_type, node);
  113.     }
  114.  
  115.     private void addGroupingNode(int node_type, VrmlObject node)
  116.         throws NoSelectedNodeException
  117.     {
  118.         String            node_name = null;
  119.         VrmlObject        parent;
  120.  
  121.         parent  = screen_list.getVrmlParent();
  122.  
  123.         switch(node_type)
  124.         {
  125.             // Grouping Nodes
  126.             case VrmlTypes.Anchor:
  127.                         node_name = "Anchor";
  128.                         break;
  129.             case VrmlTypes.BillBoard:
  130.                         node_name = "Billboard";
  131.                         break;
  132.             case VrmlTypes.Collision:
  133.                         node_name = "Collision";
  134.                         break;
  135.             case VrmlTypes.Group:
  136.                         node_name = "Group";
  137.                         break;
  138.             case VrmlTypes.Transform:
  139.                         node_name = "Transform";
  140.                         break;
  141.  
  142.             // Special Groups
  143.             case VrmlTypes.Inline:
  144.                         node_name = "Inline";
  145.                         break;
  146.             case VrmlTypes.LOD:
  147.                         node_name = "LOD";
  148.                         break;
  149.             case VrmlTypes.Switch:
  150.                         node_name = "Switch";
  151.                         break;
  152.             default:
  153.         }
  154.  
  155.         // does this screen add need to be here?
  156.         screen_list.addNode(node, node_type, node_name);
  157.         ((GroupingNode)parent).addChildren(node);
  158.     }
  159.  
  160.     private void addCommonNode(int node_type, VrmlObject node)
  161.         throws NoSelectedNodeException
  162.     {
  163.         String node_name = null;
  164.         VrmlObject    parent;
  165.  
  166.         parent  = screen_list.getVrmlParent();
  167.  
  168.         switch(node_type)
  169.         {
  170.             // Common Nodes
  171.             case VrmlTypes.AudioClip:
  172.                         node_name = "AudioClip";
  173.                         break;
  174.             case VrmlTypes.DirectionalLight:
  175.                         node_name = "DirectionalLight";
  176.                         break;
  177.             case VrmlTypes.PointLight:
  178.                         node_name = "PointLight";
  179.                         break;
  180.             case VrmlTypes.Script:
  181.                         node_name = "Script";
  182.                         break;
  183.             case VrmlTypes.Shape:
  184.                         node_name = "Shape";
  185.                         break;
  186.             case VrmlTypes.Sound:
  187.                         node_name = "Sound";
  188.                         break;
  189.             case VrmlTypes.SpotLight:
  190.                         node_name = "Spotlight";
  191.                         break;
  192.             case VrmlTypes.WorldInfo:
  193.                         node_name = "WorldInfo";
  194.                         break;
  195.             default:
  196.         }
  197.  
  198.         screen_list.addNode(node, node_type, node_name);
  199.         ((GroupingNode)parent).addChildren(node);
  200.     }
  201.  
  202.     private void addSensorNode(int node_type, VrmlObject node)
  203.         throws NoSelectedNodeException
  204.     {
  205.         String node_name = null;
  206.         VrmlObject    parent;
  207.  
  208.         parent  = screen_list.getVrmlParent();
  209.  
  210.  
  211.         switch(node_type)
  212.         {
  213.             case VrmlTypes.CylinderSensor:
  214.                         node_name = "CylinderSensor";
  215.                         break;
  216.             case VrmlTypes.PlaneSensor:
  217.                         node_name = "PlaneSensor";
  218.                         break;
  219.             case VrmlTypes.ProximitySensor:
  220.                         node_name = "ProximitySensor";
  221.                         break;
  222.             case VrmlTypes.SphereSensor:
  223.                         node_name = "SphereSensor";
  224.                         break;
  225.             case VrmlTypes.TimeSensor:
  226.                         node_name = "TimeSensor";
  227.                         break;
  228.             case VrmlTypes.TouchSensor:
  229.                         node_name = "TouchSensor";
  230.                         break;
  231.             case VrmlTypes.VisibilitySensor:
  232.                         node_name = "VisibilitySensor";
  233.                         break;
  234.             default:
  235.         }
  236.     }
  237.  
  238.     private void addGeometryNode(int node_type, VrmlObject node)
  239.         throws NoSelectedNodeException
  240.     {
  241.         String node_name = null;
  242.         VrmlObject    parent;
  243.  
  244.         parent  = screen_list.getVrmlParent();
  245.  
  246.         switch(node_type)
  247.         {
  248.             // Geometry
  249.             case VrmlTypes.Box:
  250.                         node_name = "Box";
  251.                         break;
  252.             case VrmlTypes.Cone:
  253.                         node_name = "Cone";
  254.                         break;
  255.             case VrmlTypes.Cylinder:
  256.                         node_name = "Cylinder";
  257.                         break;
  258.             case VrmlTypes.ElevationGrid:
  259.                         node_name = "ElevationGrid";
  260.                         break;
  261.             case VrmlTypes.Extrusion:
  262.                         node_name = "Extrusion";
  263.                         break;
  264.             case VrmlTypes.IndexedFaceSet:
  265.                         node_name = "IndexedFaceSet";
  266.                         break;
  267.             case VrmlTypes.IndexedLineSet:
  268.                         node_name = "IndexedLineSet";
  269.                         break;
  270.             case VrmlTypes.PointSet:
  271.                         node_name = "PointSet";
  272.                         break;
  273.             case VrmlTypes.Sphere:
  274.                         node_name = "Sphere";
  275.                         break;
  276.             case VrmlTypes.Text:
  277.                         node_name = "Text";
  278.                         break;
  279.  
  280.             default:
  281.         }
  282.  
  283.         screen_list.addNode(node, node_type, node_name);
  284.         ((Shape)parent).set_geometry((Geometry)node);
  285.  
  286.     }
  287.  
  288.     private void addGeoPropertyNode(int node_type, VrmlObject node)
  289.         throws NoSelectedNodeException
  290.     {
  291.         String node_name = null;
  292.         VrmlObject    parent;
  293.  
  294.         parent  = screen_list.getVrmlParent();
  295.  
  296.         // this is not a correct test for the geometric properties below.
  297.         // need to fix this.
  298.         if(!(parent instanceof Geometry))
  299.         {
  300.             System.out.println("Error not a piece of geometry for a parent");
  301.             return;
  302.         }
  303.  
  304.         switch(node_type)
  305.         {
  306.             // Geometric Properties
  307.             case VrmlTypes.Color:
  308.                         node_name = "Color";
  309. //                        screen_list.addNode(node, node_name);
  310. //                        ((IndexedNode)parent).set_color(node);
  311.                         break;
  312.             case VrmlTypes.Coordinate:
  313.                         node_name = "Coordinate";
  314. //                        screen_list.addNode(node, node_name);
  315. //                        ((IndexedNode)parent).set_coord(node);
  316.                         break;
  317.             case VrmlTypes.Normal:
  318.                         node_name = "Normal";
  319. //                        screen_list.addNode(node, node_name);
  320. //                        ((IndexedNode)parent).set_normal(node);
  321.                         break;
  322.             case VrmlTypes.TextureCoordinate:
  323.                         node_name = "TextureCoordinate";
  324. //                        screen_list.addNode(node, node_name);
  325. //                        ((IndexedNode)parent).set_textureCoord(node);
  326.                         break;
  327.             default:
  328.         }
  329.     }
  330.  
  331.     private void addAppearanceNode(int node_type, VrmlObject node)
  332.         throws NoSelectedNodeException
  333.     {
  334.         String node_name = null;
  335.         VrmlObject    parent;
  336.  
  337.         parent = screen_list.getVrmlParent();
  338.  
  339.         switch(node_type)
  340.         {
  341.             // Appearance
  342.             case VrmlTypes.Appearance:
  343.                     node_name = "Appearance";
  344.                     screen_list.addNode(node, VrmlTypes.Appearance, node_name);
  345.                     ((Shape)parent).set_appearance((Appearance)node);
  346.                     break;
  347.             case VrmlTypes.FontStyle:
  348.                     node_name = "FontStyle";
  349.                     break;
  350.             case VrmlTypes.ImageTexture:
  351.                     node_name = "ImageTexture";
  352.                     screen_list.addNode(node,
  353.                                         VrmlTypes.ImageTexture,
  354.                                         node_name);
  355.                     ((Appearance)parent).set_texture((Texture)node);
  356.                     break;
  357.             case VrmlTypes.Material:
  358.                     node_name = "Material";
  359.                     screen_list.addNode(node,
  360.                                         VrmlTypes.Material,
  361.                                         node_name);
  362.                     ((Appearance)parent).set_material((Material)node);
  363.                     break;
  364.             case VrmlTypes.MovieTexture:
  365.                     node_name = "MovieTexture";
  366.                     screen_list.addNode(node,
  367.                                         VrmlTypes.MovieTexture,
  368.                                         node_name);
  369.                     ((Appearance)parent).set_texture((Texture)node);
  370.                     break;
  371.             case VrmlTypes.PixelTexture:
  372.                     node_name = "PixelTexture";
  373.                     screen_list.addNode(node,
  374.                                         VrmlTypes.PixelTexture,
  375.                                         node_name);
  376.                     ((Appearance)parent).set_texture((Texture)node);
  377.                     break;
  378.             case VrmlTypes.TextureTransform:
  379.                     node_name = "TextureTransform";
  380.                     screen_list.addNode(node,
  381.                                         VrmlTypes.TextureTransform,
  382.                                         node_name);
  383.                     ((Appearance)parent).set_textureTransform((TextureTransform)node);
  384.                     break;
  385.             default:
  386.         }
  387.     }
  388.  
  389.     private void addInterpolatorNode(int node_type, VrmlObject node)
  390.         throws NoSelectedNodeException
  391.     {
  392.         String node_name = null;
  393.         VrmlObject    parent;
  394.  
  395.         parent  = screen_list.getVrmlParent();
  396.  
  397.  
  398.         switch(node_type)
  399.         {
  400.             case VrmlTypes.ColorInterpolator:
  401.                         node_name = "ColorInterpolator";
  402.                         break;
  403.             case VrmlTypes.CoordinateInterpolator:
  404.                         node_name = "CoordinateInterpolator";
  405.                         break;
  406.             case VrmlTypes.NormalInterpolator:
  407.                         node_name = "NormalInterpolator";
  408.                         break;
  409.             case VrmlTypes.OrientationInterpolator:
  410.                         node_name = "OrientationInterpolator";
  411.                         break;
  412.             case VrmlTypes.PositionInterpolator:
  413.                         node_name = "PositionInterpolator";
  414.                         break;
  415.             case VrmlTypes.ScalarInterpolator:
  416.                         node_name = "ScalarInterpolator";
  417.                         break;
  418.             default:
  419.         }
  420.     }
  421.  
  422.     private void addBindableNode(int node_type, VrmlObject node)
  423.         throws NoSelectedNodeException
  424.     {
  425.         String node_name = null;
  426.         VrmlObject    parent;
  427.  
  428.         parent  = screen_list.getVrmlParent();
  429.  
  430.         switch(node_type)
  431.         {
  432.             // Bindable nodes
  433.             case VrmlTypes.BackGround:
  434.                         node_name = "BackGround";
  435.                         break;
  436.             case VrmlTypes.Fog:
  437.                         node_name = "Fog";
  438.                         break;
  439.             case VrmlTypes.NavigationInfo:
  440.                         node_name = "NavigationInfo";
  441.                         break;
  442.             case VrmlTypes.Viewpoint:
  443.                         node_name = "Viewpoint";
  444.                         break;
  445.             default:
  446.         }
  447.     }
  448.  
  449.     public void deleteNode(int parent_type,
  450.                            VrmlObject parent,
  451.                            int child_type,
  452.                            VrmlObject child)
  453.     {
  454.         // do the quickest and most common cases first: geometry and groups.
  455.         if(parent instanceof GroupingNode)
  456.         {
  457.             ((GroupingNode)parent).removeChildren(child);
  458.             return;
  459.         }
  460.  
  461.         if(child instanceof Geometry)
  462.         {
  463.             ((Shape)parent).set_geometry(null);
  464.             return;
  465.         }
  466.  
  467.         switch(child_type)
  468.         {
  469.             case VrmlTypes.Appearance:
  470.                     ((Shape)parent).set_appearance(null);
  471.                     break;
  472.             case VrmlTypes.ImageTexture:
  473.             case VrmlTypes.MovieTexture:
  474.             case VrmlTypes.PixelTexture:
  475.                     ((Appearance)parent).set_texture(null);
  476.                     break;
  477.             case VrmlTypes.TextureTransform:
  478.                     ((Appearance)parent).set_textureTransform(null);
  479.                     break;
  480.             default:
  481.                 System.out.println("Deleting node type not implemented yet");
  482.         }
  483.     }
  484.  
  485.     public void deleteAll()
  486.     {
  487.         file_root = null;
  488.  
  489.         file_root = new VrmlRoot();
  490.         screen_list.setVrmlRoot(file_root);
  491.     }
  492. }
  493.