org.simantics.g3d.vtk/src/org/simantics/g3d/vtk/swt/vtkCameraAndSelectorAction.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
   3  * Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.g3d.vtk.swt;
  13
  14 import java.awt.event.InputEvent;
  15 import java.awt.event.MouseEvent;
  16 import java.awt.event.MouseWheelEvent;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.List;
  20
  21 import org.eclipse.jface.viewers.ISelection;
  22 import org.eclipse.jface.viewers.ISelectionChangedListener;
  23 import org.eclipse.jface.viewers.ISelectionProvider;
  24 import org.eclipse.jface.viewers.SelectionChangedEvent;
  25 import org.eclipse.jface.viewers.StructuredSelection;
  26 import org.eclipse.swt.widgets.Display;
  27 import org.simantics.g3d.tools.AdaptationUtils;
  28
  29 import vtk.vtkCamera;
  30 import vtk.vtkProp;
  31 import vtk.vtkRenderWindow;
  32 import vtk.vtkRenderer;
  33
  34 public class vtkCameraAndSelectorAction extends vtkSwtAction implements ISelectionProvider {
  35
  36         protected vtkRenderer ren;
  37         protected int lastX;
  38         protected int lastY;
  39         protected vtkRenderWindow rw;
  40         protected vtkCamera cam;
  41         protected int InteractionMode = 1;
  42
  43         protected double activeRate = 5.0;
  44         protected double passiveRate = 0.01;
  45         protected boolean doNotRotate = true;
  46         private double[] upDirection = new double[] { 0, 1, 0 };
  47
  48         public vtkCameraAndSelectorAction(InteractiveVtkComposite panel) {
  49                 super(panel);
  50                 this.ren = panel.getRenderer();
  51                 this.rw = panel.getRenderWindow();
  52                 this.cam = ren.GetActiveCamera();
  53         }
  54
  55         public void setUpDirection(double[] upDirection) {
  56                 this.upDirection = upDirection;
  57         }
  58
  59         public void Lock() {
  60                 panel.lock();
  61         }
  62
  63         public void UnLock() {
  64                 panel.unlock();
  65         }
  66
  67         public void InteractionModeRotate() {
  68                 this.InteractionMode = 1;
  69         }
  70
  71         public void InteractionModeTranslate() {
  72                 this.InteractionMode = 2;
  73         }
  74
  75         public void InteractionModeZoom() {
  76                 this.InteractionMode = 3;
  77         }
  78
  79         public void resetCameraClippingRange() {
  80                 Lock();
  81                 ren.ResetCameraClippingRange();
  82                 UnLock();
  83         }
  84
  85         public void resetCamera() {
  86                 Lock();
  87                 ren.ResetCamera();
  88                 UnLock();
  89         }
  90
  91         public boolean mousePressed(MouseEvent e) {
  92
  93                 if (ren.VisibleActorCount() == 0)
  94                         return false;
  95                 rw.SetDesiredUpdateRate(activeRate);
  96                 lastX = e.getX();
  97                 lastY = e.getY();
  98                 if ((e.getModifiers() == InputEvent.BUTTON2_MASK)
  99                                 || (e.getModifiers() == (InputEvent.BUTTON1_MASK | InputEvent.SHIFT_MASK))) {
 100                         InteractionModeTranslate();
 101                 } else if (e.getModifiers() == InputEvent.BUTTON3_MASK) {
 102                         InteractionModeZoom();
 103                 } else {
 104                         InteractionModeRotate();
 105                 }
 106                 return true;
 107         }
 108
 109         public boolean mouseReleased(MouseEvent e) {
 110                 rw.SetDesiredUpdateRate(passiveRate);
 111                 return true;
 112         }
 113
 114         public boolean mouseDragged(MouseEvent e) {
 115                 if (ren.VisibleActorCount() == 0)
 116                         return false;
 117                 int x = e.getX();
 118                 int y = e.getY();
 119                 // rotate
 120                 if (this.InteractionMode == 1) {
 121                         cam.Azimuth(lastX - x);
 122                         cam.Elevation(y - lastY);
 123                         if (doNotRotate)
 124                                 cam.SetViewUp(upDirection);
 125                         cam.OrthogonalizeViewUp();
 126                         resetCameraClippingRange();
 127                         // panel.UpdateLight();
 128                 }
 129                 // translate
 130                 if (this.InteractionMode == 2) {
 131                         double FPoint[];
 132                         double PPoint[];
 133                         double APoint[];
 134                         double RPoint[];
 135
 136                         // get the current focal point and position
 137                         FPoint = cam.GetFocalPoint();
 138                         PPoint = cam.GetPosition();
 139
 140                         // calculate the focal depth since we'll be using it a lot
 141                         ren.SetWorldPoint(FPoint[0], FPoint[1], FPoint[2], 1.0);
 142                         ren.WorldToDisplay();
 143                         APoint = ren.GetDisplayPoint();
 144
 145 //                      int[] size = rw.GetSize();
 146                         APoint[0] -= x - lastX;
 147                         APoint[1] += y - lastY;
 148                         ren.SetDisplayPoint(APoint);
 149                         ren.DisplayToWorld();
 150                         RPoint = ren.GetWorldPoint();
 151
 152                         if (RPoint[3] != 0.0) {
 153                                 RPoint[0] = RPoint[0] / RPoint[3];
 154                                 RPoint[1] = RPoint[1] / RPoint[3];
 155                                 RPoint[2] = RPoint[2] / RPoint[3];
 156                         }
 157
 158                         /*
 159                          * Compute a translation vector, moving everything 1/2 the distance to the
 160                          * cursor. (Arbitrary scale factor)
 161                          */
 162                         cam.SetFocalPoint(RPoint);
 163                         cam.SetPosition((RPoint[0] - FPoint[0]) + PPoint[0], (RPoint[1] - FPoint[1]) + PPoint[1],
 164                                         (RPoint[2] - FPoint[2]) + PPoint[2]);
 165                         resetCameraClippingRange();
 166                 }
 167                 // zoom
 168                 if (this.InteractionMode == 3) {
 169                         double zoomFactor;
 170                         // double clippingRange[];
 171
 172                         zoomFactor = Math.pow(1.02, (y - lastY));
 173                         if (cam.GetParallelProjection() == 1) {
 174                                 cam.SetParallelScale(cam.GetParallelScale() / zoomFactor);
 175                                 resetCameraClippingRange();
 176                         } else {
 177                                 cam.Dolly(zoomFactor);
 178                                 resetCameraClippingRange();
 179                         }
 180                 }
 181                 lastX = x;
 182                 lastY = y;
 183                 panel.refresh();
 184                 return true;
 185         }
 186
 187         @Override
 188         public boolean mouseWheelMoved(MouseWheelEvent e) {
 189                 double zoomFactor;
 190                 // double clippingRange[];
 191                 zoomFactor = Math.pow(1.02, (e.getWheelRotation()));
 192                 if (cam.GetParallelProjection() == 1) {
 193                         cam.SetParallelScale(cam.GetParallelScale() / zoomFactor);
 194                 } else {
 195                         cam.Dolly(zoomFactor);
 196                         resetCameraClippingRange();
 197                 }
 198                 panel.refresh();
 199                 return true;
 200         }
 201
 202         protected List<vtkProp> selectActors = new ArrayList<vtkProp>();
 203         protected List<vtkProp> hoverActor = new ArrayList<vtkProp>();
 204
 205         @Override
 206         public boolean mouseClicked(MouseEvent e) {
 207                 if (!panel.getComponent().isFocusControl())
 208                         return false;
 209                 if (e.getButton() != MouseEvent.BUTTON1)
 210                         return false;
 211                 vtkProp spick[] = panel.pick(e.getX(), e.getY());
 212                 if (spick != null && spick.length > 0) {
 213                         for (vtkProp selectActor : spick) {
 214                                 if (!e.isControlDown()) {
 215                                         selectActors.clear();
 216                                         selectActors.add(selectActor);
 217                                 } else {
 218                                         if (selectActors.contains(selectActor))
 219                                                 selectActors.remove(selectActor);
 220                                         else
 221                                                 selectActors.add(selectActor);
 222                                 }
 223                         }
 224                         fireSelectionChanged();
 225                 } else if (!e.isControlDown()) {
 226                         selectActors.clear();
 227                         fireSelectionChanged();
 228                 }
 229                 return true;
 230                 // if (e.getClickCount() > 1)
 231                 // updatePickRay(e.getX(), e.getY());
 232
 233         }
 234
 235         // private void updatePickRay(double x , double y) {
 236         // Ray ray = vtkUtil.createMouseRay(panel.GetRenderer(), x, y);
 237         //
 238         //
 239         // System.out.println(ray.pos + " " + ray.dir);
 240         // vtkPoints linePoints = new vtkPoints();
 241         // linePoints.InsertPoint(0,ray.pos.x, ray.pos.y, ray.pos.z);
 242         // linePoints.InsertPoint(1, ray.pos.x + ray.dir.x, ray.pos.y + ray.dir.y,
 243         // ray.pos.z + ray.dir.z);
 244         // vtkLine aLine = new vtkLine();
 245         // aLine.GetPointIds().SetId(0, 0);
 246         // aLine.GetPointIds().SetId(1, 1);
 247         // vtkUnstructuredGrid aLineGrid = new vtkUnstructuredGrid();
 248         // aLineGrid.Allocate(1, 1);
 249         // aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds());
 250         // aLineGrid.SetPoints(linePoints);
 251         // vtkDataSetMapper aLineMapper = new vtkDataSetMapper();
 252         // aLineMapper.SetInput(aLineGrid);
 253         // vtkActor aLineActor = new vtkActor();
 254         // aLineActor.SetMapper(aLineMapper);
 255         // aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1);
 256         //
 257         // if (rayActor != null) {
 258         // panel.GetRenderer().RemoveActor(rayActor);
 259         // rayActor.Delete();
 260         // }
 261         // rayActor = aLineActor;
 262         // panel.GetRenderer().AddActor(rayActor);
 263         //
 264         // linePoints.Delete();
 265         // aLine.Delete();
 266         // aLineGrid.Delete();
 267         // aLineMapper.Delete();
 268         // panel.repaint();
 269         // }
 270         //
 271         // private vtkActor rayActor;
 272
 273         @Override
 274         public boolean mouseMoved(MouseEvent e) {
 275                 lastX = e.getX();
 276                 lastY = e.getY();
 277
 278                 if (!panel.getComponent().isFocusControl())
 279                         return false;
 280                 List<vtkProp> prevHover = new ArrayList<vtkProp>();
 281                 prevHover.addAll(hoverActor);
 282                 hoverActor.clear();
 283                 vtkProp pick[] = panel.pick(e.getX(), e.getY());
 284                 if (pick != null) {
 285                         for (vtkProp p : pick)
 286                                 hoverActor.add(p);
 287                 }
 288
 289                 if (!prevHover.containsAll(hoverActor) || !hoverActor.containsAll(prevHover)) {
 290                         fireHoverChanged();
 291                 }
 292                 return true;
 293         }
 294
 295         public List<vtkProp> getSelectActor() {
 296                 return selectActors;
 297         }
 298
 299         public List<vtkProp> getHoverActor() {
 300                 return hoverActor;
 301         }
 302
 303         private List<ISelectionChangedListener> selectionListeners = new ArrayList<ISelectionChangedListener>();
 304
 305         @Override
 306         public void addSelectionChangedListener(ISelectionChangedListener listener) {
 307                 selectionListeners.add(listener);
 308         }
 309
 310         @Override
 311         public ISelection getSelection() {
 312                 return new StructuredSelection(selectActors);
 313         }
 314
 315         @Override
 316         public void removeSelectionChangedListener(ISelectionChangedListener listener) {
 317                 selectionListeners.remove(listener);
 318         }
 319
 320         @Override
 321         public void setSelection(ISelection selection) {
 322                 setSelection(selection, false);
 323
 324         }
 325
 326         public void setSelection(ISelection selection, boolean fire) {
 327                 Collection<vtkProp> selectedProps = AdaptationUtils.adaptToCollection(selection, vtkProp.class);
 328
 329                 selectActors.clear();
 330                 selectActors.addAll(selectedProps);
 331                 if (fire)
 332                         fireSelectionChanged();
 333         }
 334
 335         protected void fireSelectionChanged() {
 336                 Display.getDefault().asyncExec(new Runnable() {
 337                         @Override
 338                         public void run() {
 339
 340                                 SelectionChangedEvent evt = new SelectionChangedEvent(vtkCameraAndSelectorAction.this,
 341                                                 new StructuredSelection(selectActors));
 342                                 for (ISelectionChangedListener l : selectionListeners) {
 343                                         l.selectionChanged(evt);
 344                                 }
 345
 346                         }
 347                 });
 348         }
 349
 350         private List<ISelectionChangedListener> hoverListeners = new ArrayList<ISelectionChangedListener>();
 351
 352         public void addHoverChangedListener(ISelectionChangedListener listener) {
 353                 hoverListeners.add(listener);
 354         }
 355
 356         public ISelection getHoverSelection() {
 357                 return new StructuredSelection(hoverActor);
 358         }
 359
 360         public void removeHoverChangedListener(ISelectionChangedListener listener) {
 361                 hoverListeners.remove(listener);
 362         }
 363
 364         private void fireHoverChanged() {
 365                 Display.getDefault().asyncExec(new Runnable() {
 366                         @Override
 367                         public void run() {
 368                                 StructuredSelection sel = null;
 369                                 if (hoverActor == null)
 370                                         sel = new StructuredSelection();
 371                                 else
 372                                         sel = new StructuredSelection(hoverActor);
 373                                 SelectionChangedEvent evt = new SelectionChangedEvent(vtkCameraAndSelectorAction.this, sel);
 374                                 for (ISelectionChangedListener l : hoverListeners) {
 375                                         l.selectionChanged(evt);
 376                                 }
 377
 378                         }
 379                 });
 380         }
 381
 382         public void focus(double x, double y, double z) {
 383                 Lock();
 384                 cam.SetFocalPoint(x, y, z);
 385                 if (doNotRotate)
 386                         cam.SetViewUp(upDirection);
 387                 cam.OrthogonalizeViewUp();
 388                 resetCameraClippingRange();
 389                 // panel.UpdateLight();
 390                 UnLock();
 391         }
 392
 393 }