org.simantics.plant3d/src/org/simantics/plant3d/editor/P3DNodeMap.java

   1 package org.simantics.plant3d.editor;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.HashSet;
   6 import java.util.List;
   7 import java.util.Set;
   8
   9 import org.simantics.db.ReadGraph;
  10 import org.simantics.db.Session;
  11 import org.simantics.db.exception.DatabaseException;
  12 import org.simantics.g3d.ontology.G3D;
  13 import org.simantics.g3d.scenegraph.base.INode;
  14 import org.simantics.g3d.scenegraph.base.ParentNode;
  15 import org.simantics.g3d.vtk.common.AbstractVTKNodeMap;
  16 import org.simantics.g3d.vtk.common.InteractiveVtkPanel;
  17 import org.simantics.objmap.graph.IMapping;
  18 import org.simantics.plant3d.ontology.Plant3D;
  19 import org.simantics.plant3d.scenegraph.IP3DNode;
  20 import org.simantics.plant3d.scenegraph.IP3DVisualNode;
  21 import org.simantics.plant3d.scenegraph.P3DParentNode;
  22 import org.simantics.plant3d.scenegraph.P3DRootNode;
  23 import org.simantics.plant3d.scenegraph.ParameterizedNode;
  24 import org.simantics.plant3d.scenegraph.PipeRun;
  25 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
  26 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
  27 import org.simantics.utils.threads.AWTThread;
  28
  29 import vtk.vtkProp;
  30 import vtk.vtkProp3D;
  31
  32 public class P3DNodeMap extends AbstractVTKNodeMap<INode> {
  33
  34         private static final boolean DEBUG = false;
  35
  36         public P3DNodeMap(Session session, IMapping mapping, InteractiveVtkPanel panel, P3DRootNode rootNode) {
  37                 super(session, mapping, panel, rootNode);
  38                 rootNode.setNodeMap(this);
  39         }
  40         @Override
  41         protected void updateActor(INode n, Set<String> ids) {
  42                 if (DEBUG) System.out.println("P3DNodeMap update " + n);
  43                 if (!(n instanceof IP3DVisualNode)) {
  44                         if (n instanceof PipeControlPoint) {
  45                                 n = ((PipeControlPoint)n).getPipelineComponent();
  46                                 if (n == null)
  47                                         return;
  48                         } else {
  49                                 return;
  50                         }
  51                 }
  52
  53                 IP3DVisualNode node = (IP3DVisualNode)n;
  54
  55                 if (DEBUG) {
  56                         System.out.print("P3DNodeMap update " + node);
  57                         for (String s : ids)
  58                                 System.out.print(" " + s);
  59                         System.out.println();
  60                 }
  61
  62                 if (ids.contains(Plant3D.URIs.hasGeometry)) {
  63                         node.visualize(panel);
  64                         updateRenderObjectsFor(node);
  65                         updateTransform(node);
  66                 }
  67                 if (n instanceof ParameterizedNode) {
  68                         ParameterizedNode geom = (ParameterizedNode)n;
  69                         for (String id : geom.getParameterMap().keySet()) {
  70                                 if (ids.contains(id)) {
  71                                         node.visualize(panel);
  72                                         updateRenderObjectsFor(node);
  73                                         updateTransform(node);
  74                                         break;
  75                                 }
  76                         }
  77                 } else if (n instanceof PipeRun) {
  78                         // FIXME: may require rule based update!
  79                         PipeRun run = (PipeRun)n;
  80                         Set<String> ids2 = new HashSet<String>();
  81                         ids2.add(Plant3D.URIs.hasGeometry);
  82                         for (PipeControlPoint pcp : run.getControlPoints()) {
  83                                 updateActor(pcp, ids2);
  84                         }
  85                 }
  86
  87                 if (ids.contains(G3D.URIs.hasPosition) ||
  88                         ids.contains(G3D.URIs.hasOrientation) ||
  89                         ids.contains(G3D.URIs.hasWorldPosition) ||
  90                         ids.contains(G3D.URIs.hasWorldOrientation)) {
  91                         updateTransform(node);
  92                 }
  93         }
  94
  95         private void updateTransform(IP3DNode node) {
  96                 if (DEBUG) System.out.println("P3DNodeMap update Transform " + node);
  97
  98                 node.update(panel.GetRenderer());
  99
 100                 if (node instanceof ParentNode<?>) {
 101                         ParentNode<IP3DNode> p = (ParentNode<IP3DNode>)node;
 102                         for (IP3DNode n : p.getNodes())
 103                                 updateTransform(n);
 104                 }
 105         }
 106
 107         @Override
 108         protected Collection<vtkProp> getActors(INode n) {
 109                 List<vtkProp> props = new ArrayList<vtkProp>();
 110                 if (!(n instanceof IP3DVisualNode))
 111                         return props;
 112                 IP3DVisualNode node = (IP3DVisualNode)n;
 113                 for (vtkProp3D p : ((IP3DVisualNode)node).getActors())
 114                         props.add(p);
 115
 116                 return props;
 117         }
 118
 119         @Override
 120         protected void removeActor(INode n) {
 121                 if (DEBUG) System.out.println("P3DNodeMap.removeActor " + n);
 122                 if (!(n instanceof IP3DVisualNode))
 123                         return;
 124                 IP3DVisualNode node = (IP3DVisualNode)n;
 125                 remActor(node);
 126
 127                 if (node instanceof P3DParentNode<?>) {
 128                         for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
 129                                 if (n2 instanceof IP3DVisualNode)
 130                                         removeActor((IP3DVisualNode)n2);
 131                 }
 132         }
 133
 134         @Override
 135         protected void addActor(INode n) {
 136                 if (DEBUG) System.out.println("P3DNodeMap.addActor " + n);
 137                 if (!(n instanceof IP3DVisualNode))
 138                         return;
 139                 IP3DVisualNode node = (IP3DVisualNode)n;
 140
 141                 if (hasActor(node))
 142                         return;
 143                 if (Thread.currentThread() != AWTThread.getThreadAccess().getThread())
 144                         throw new RuntimeException("Illegal thread.");
 145
 146                 panel.lock();
 147
 148                 node.visualize(panel);
 149
 150                 for (vtkProp3D act : node.getActors()) {
 151                         nodeToActor.add(node, act);
 152             actorToNode.put(act, node);
 153                 }
 154
 155                 if (node instanceof P3DParentNode<?>) {
 156                         for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
 157                                 if (n2 instanceof IP3DVisualNode)
 158                                         addActor((IP3DVisualNode)n2);
 159                 }
 160
 161                 updateTransform(node);
 162
 163         panel.unlock();
 164
 165         }
 166
 167
 168
 169         private boolean hasActor(IP3DVisualNode node) {
 170                 List<vtkProp> list = nodeToActor.getValues(node);
 171                 if (list == null || list.size() == 0)
 172                         return false;
 173                 return true;
 174         }
 175
 176         private void remActor(IP3DVisualNode node) {
 177                 if (Thread.currentThread() != AWTThread.getThreadAccess().getThread())
 178                         throw new RuntimeException("Illegal thread.");
 179
 180                 List<vtkProp> list = nodeToActor.getValues(node);
 181                 if (list != null) {
 182                         for (vtkProp obj : list) {
 183                                 actorToNode.remove(obj);
 184                         }
 185                         nodeToActor.remove(node);
 186                         panel.lock();
 187
 188                         node.stopVisualize();
 189
 190                         panel.unlock();
 191                 }
 192         }
 193
 194         @Override
 195         protected void update(ReadGraph graph) throws DatabaseException {
 196                 validate();
 197 //              System.out.println("Graph updates");
 198                 super.update(graph);
 199                 validate();
 200         }
 201
 202         @Override
 203         public void commit() {
 204                 validate();
 205 //              System.out.println("Graph commit");
 206                 super.commit();
 207
 208         }
 209         @Override
 210         protected void doCommit() {
 211 //              System.out.println("Do commit");
 212                 validate();
 213                 super.doCommit();
 214         }
 215
 216         private void validate() {
 217                 for (INode node : rootNode.getNodes()) {
 218                         if (node instanceof PipeRun)
 219                                 PipingRules.validate((PipeRun)node);
 220                 }
 221         }
 222
 223         @Override
 224         public synchronized void preRender() {
 225 //              System.out.println("P3DNodeMap preRender");
 226 //              super.preRender();
 227                 try {
 228 //                      boolean b = false;
 229 //                      synchronized (syncMutex) {
 230 //                              b = PipingRules.update();
 231 //                      }
 232 //                      if (b)
 233 //                              super.preRender();
 234                         boolean b = true;
 235                         while (b) {
 236                                 updateCycle();
 237                                 b = PipingRules.update();
 238                         }
 239                 } catch (Exception e) {
 240                         e.printStackTrace();
 241                 }
 242
 243         }
 244
 245 }