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