Ignore:
Timestamp:
May 13, 2008, 6:30:22 PM (16 years ago)
Author:
garnier
Message:

r832@wl-72126: garnier | 2008-05-13 18:30:21 +0200
mise a jour du SPINNING

Location:
trunk/geant4/visualization/OpenGL
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/geant4/visualization/OpenGL/include/G4OpenGLQtViewer.hh

    r754 r797  
    5858class QKeyEvent;
    5959class QProcess;
     60class QTime;
    6061
    6162class G4OpenGLSceneHandler;
    … …  
    9293  void manageContextMenuEvent(QContextMenuEvent *e);
    9394#if QT_VERSION < 0x040000
    94   void G4MousePressEvent(QPoint, Qt::ButtonState);
    95 #else
    96   void G4MousePressEvent(QPoint, Qt::MouseButtons);
    97 #endif
     95  void G4MousePressEvent(QPoint);
     96#else
     97  void G4MousePressEvent(QPoint);
     98#endif
     99  void G4MouseReleaseEvent();
    98100  void G4MouseDoubleClickEvent(QPoint p);
    99101#if QT_VERSION < 0x040000
    100   void G4MouseMoveEvent(int, int, Qt::ButtonState,bool mAutoMove = false);
    101 #else
    102   void G4MouseMoveEvent(int, int, Qt::MouseButtons,bool mAutoMove = false);
     102  void G4MouseMoveEvent(int, int, Qt::ButtonState);
     103#else
     104  void G4MouseMoveEvent(int, int, Qt::MouseButtons);
    103105#endif
    104106  void G4keyPressEvent (QKeyEvent * event);
    105   void rotateScene(G4double, G4double,bool mAutoRotate=false);
    106   void moveScene(G4double, G4double, G4double,bool,bool mAutoMove=false);
     107  void rotateScene(int, int);
     108  void moveScene(int, int, int,bool);
    107109
    108110
    … …  
    183185  RECORDING_STEP fRecordingStep;
    184186  QProcess *fProcess;
     187  QTime *fLastEventTime;
     188  int fSpinningDelay;
    185189
    186190private slots :

  • trunk/geant4/visualization/OpenGL/src/G4OpenGLQtViewer.cc

    r790 r797  
    3636#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
    3737
    38 //#define GEANT4_QT_DEBUG
     38#define GEANT4_QT_DEBUG
    3939
    4040#include "G4OpenGLQtViewer.hh"
    … …  
    7777#include <qdialog.h>
    7878#include <qevent.h> //include <qcontextmenuevent.h>
    79 
     79#include <qdatetime.h>
    8080
    8181//////////////////////////////////////////////////////////////////////////////
    … …  
    316316  initMovieParameters();
    317317
     318  fLastEventTime = new QTime();
     319
    318320#ifdef GEANT4_QT_DEBUG
    319321  printf("G4OpenGLQtViewer::G4OpenGLQtViewer END\n");
    … …  
    15071509*/
    15081510#if QT_VERSION < 0x040000
    1509 void G4OpenGLQtViewer::G4MousePressEvent(QPoint p,Qt::ButtonState mButtons)
    1510 #else
    1511 void G4OpenGLQtViewer::G4MousePressEvent(QPoint p,Qt::MouseButtons mButtons)
     1511void G4OpenGLQtViewer::G4MousePressEvent(QPoint p)
     1512#else
     1513void G4OpenGLQtViewer::G4MousePressEvent(QPoint p)
    15121514#endif
    15131515{
    15141516  fAutoMove = false; // stop automove
    15151517  fLastPos = p;
     1518  fLastEventTime->start();
    15161519  if (fMouseAction == STYLE2){  // pick
    15171520    Pick(p.x(),p.y());
     1521  }
     1522}
     1523
     1524/**
     1525*/
     1526void G4OpenGLQtViewer::G4MouseReleaseEvent()
     1527{
     1528  fSpinningDelay = fLastEventTime->elapsed();
     1529#ifdef GEANT4_QT_DEBUG
     1530  printf("G4OpenGLQtViewer::G4MouseReleaseEvent delay %d\n",fSpinningDelay);
     1531#endif
     1532  if ((fDeltaPosX == 0) && (fDeltaPosY == 0)) {
     1533    return;
     1534  }
     1535  if (fSpinningDelay < 100 ) {
     1536    fAutoMove = true;
     1537
     1538    QTime lastMoveTime;
     1539    lastMoveTime.start();
     1540    // try to addapt speed move/rotate looking to drawing speed
     1541    int cycles = 4;
     1542    while (fAutoMove) {
     1543      if ( lastMoveTime.elapsed() > (100 / (cycles/2))) {
     1544        if (fMouseAction == STYLE1) {  // rotate
     1545          rotateScene(fDeltaPosX,fDeltaPosY);
     1546        } else if (fMouseAction == STYLE2) {  // move
     1547          moveScene(-fDeltaPosX,-fDeltaPosY,0,true);
     1548        }
     1549        lastMoveTime.start();
     1550        cycles = 1 ;
     1551      }
     1552      ((QApplication*)G4Qt::getInstance ())->processEvents();
     1553      cycles ++ ;
     1554    }
     1555    fDeltaPosX = 0;
     1556    fDeltaPosY = 0;
     1557   
    15181558  }
    15191559}
    … …  
    15281568
    15291569#if QT_VERSION < 0x040000
    1530 void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::ButtonState mButtons,bool mAutoMove)
    1531 #else
    1532   void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::MouseButtons mButtons,bool mAutoMove)
     1570void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::ButtonState mButtons)
     1571#else
     1572  void G4OpenGLQtViewer::G4MouseMoveEvent(int pos_x, int pos_y,Qt::MouseButtons mButtons)
    15331573#endif
    15341574{
    1535   fAutoMove = mAutoMove;
    1536 
    1537   if (!fAutoMove) {  // keep old delta if automove
    1538     fDeltaPosX = fLastPos.x() - pos_x;
    1539     fDeltaPosY = fLastPos.y() - pos_y;
    1540   }
    1541 
    1542   if ((fDeltaPosX == 0) && (fDeltaPosY == 0)) {
    1543     fAutoMove = false;
    1544   }
    1545 
     1575
     1576  if (fAutoMove) {
     1577    return;
     1578  }
     1579
     1580  fDeltaPosX = fLastPos.x() - pos_x;
     1581  fDeltaPosY = fLastPos.y() - pos_y;
     1582 
    15461583  if (fMouseAction == STYLE1) {  // rotate
    15471584    if (mButtons & Qt::LeftButton) {
    1548       rotateScene(fDeltaPosX,fDeltaPosY,fAutoMove);
     1585      rotateScene(fDeltaPosX,fDeltaPosY);
    15491586    }
    15501587  } else if (fMouseAction == STYLE2) {  // move
    15511588    if (mButtons & Qt::LeftButton) {
    1552       if (fAutoMove) {
    1553         while (fAutoMove) {
    1554           moveScene(-fDeltaPosX,-fDeltaPosY,0,true,true);
    1555           ((QApplication*)G4Qt::getInstance ())->processEvents();
    1556         }
    1557       } else {
    1558         moveScene(-fDeltaPosX,-fDeltaPosY,0,true,false);
    1559       }
     1589      moveScene(-fDeltaPosX,-fDeltaPosY,0,true);
    15601590    }
    15611591  }
    15621592  fLastPos = QPoint(pos_x, pos_y);
     1593  fLastEventTime->start();
    15631594}
    15641595
    … …  
    15711602*/
    15721603
    1573 void G4OpenGLQtViewer::moveScene(G4double dx,G4double dy, G4double dz,bool mouseMove,bool mAutoMove)
     1604void G4OpenGLQtViewer::moveScene(int dx,int dy, int dz,bool mouseMove)
    15741605{
    15751606  if (fHoldMoveEvent)
    … …  
    15771608  fHoldMoveEvent = true;
    15781609
    1579   if( mAutoMove == false) {
    1580     fAutoMove = true;
    1581   }
    15821610  G4double coefTrans = 0;
    15831611  GLdouble coefDepth = 0;
    1584   while (fAutoMove) {
    1585     if( mAutoMove == false) {
    1586       fAutoMove = false;
    1587     }
    1588     if(mouseMove) {
    1589       coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_x);
    1590       if (WinSize_y <WinSize_x) {
    1591         coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_y);
    1592       }
    1593     } else {
    1594       coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
    1595       coefDepth = getSceneDepth()*fDeltaDepth;
    1596     }
    1597     fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
    1598    
    1599     updateQWidget();
    1600     if (fAutoMove)
    1601       ((QApplication*)G4Qt::getInstance ())->processEvents();
    1602   }
    1603 
     1612  if(mouseMove) {
     1613    coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_x);
     1614    if (WinSize_y <WinSize_x) {
     1615      coefTrans = ((G4double)getSceneNearWidth())/((G4double)WinSize_y);
     1616    }
     1617  } else {
     1618    coefTrans = getSceneNearWidth()*fDeltaSceneTranslation;
     1619    coefDepth = getSceneDepth()*fDeltaDepth;
     1620  }
     1621  fVP.IncrementPan(-dx*coefTrans,dy*coefTrans,dz*coefDepth);
     1622 
     1623  updateQWidget();
     1624  if (fAutoMove)
     1625    ((QApplication*)G4Qt::getInstance ())->processEvents();
     1626 
    16041627  fHoldMoveEvent = false;
    16051628}
    … …  
    16111634*/
    16121635
    1613 void G4OpenGLQtViewer::rotateScene(G4double dx, G4double dy,bool mAutoRotate)
     1636void G4OpenGLQtViewer::rotateScene(int dx, int dy)
    16141637{
     1638#ifdef GEANT4_QT_DEBUG
     1639  printf("G4OpenGLQtViewer::rotateScene %d %d\n",dx,dy);
     1640#endif
     1641
    16151642  if (fHoldRotateEvent)
    16161643    return;
    16171644  fHoldRotateEvent = true;
    16181645
    1619   if( mAutoRotate == false) {
    1620     fAutoMove = true;
    1621   }
    16221646  G4Vector3D vp;
    16231647  G4Vector3D up;
    … …  
    16411665  G4Vector3D viewPoint;
    16421666
    1643   while (fAutoMove) {
    1644     if( mAutoRotate == false) {
    1645       fAutoMove = false;
    1646     }
    16471667   
    1648     //phi spin stuff here
    1649  
    1650     vp = fVP.GetViewpointDirection ().unit ();
    1651     up = fVP.GetUpVector ().unit ();
    1652  
    1653     yprime = (up.cross(vp)).unit();
    1654     zprime = (vp.cross(yprime)).unit();
    1655  
    1656     if (fVP.GetLightsMoveWithCamera()) {
    1657       delta_alpha = dy * fDeltaRotation;
    1658       delta_theta = -dx * fDeltaRotation;
    1659     } else {
    1660       delta_alpha = -dy * fDeltaRotation;
    1661       delta_theta = dx * fDeltaRotation;
    1662     }   
    1663  
    1664     delta_alpha *= deg;
    1665     delta_theta *= deg;
    1666  
    1667     new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
    1668 
    1669     // to avoid z rotation flipping
    1670     // to allow more than 360° rotation
    1671     if (fVP.GetLightsMoveWithCamera()) {
    1672       new_up = (new_vp.cross(yprime)).unit();
    1673       if (new_vp.z()*vp.z() <0) {
    1674         new_up.set(new_up.x(),-new_up.y(),new_up.z());
    1675       }
    1676     } else {
    1677       new_up = up;
    1678       if (new_vp.z()*vp.z() <0) {
    1679         new_up.set(new_up.x(),-new_up.y(),new_up.z());
    1680       }
    1681     }
    1682     fVP.SetUpVector(new_up);
    1683     ////////////////
    1684     // Rotates by fixed azimuthal angle delta_theta.
    1685    
    1686     cosalpha = new_up.dot (new_vp.unit());
    1687     sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
    1688     yprime = (new_up.cross (new_vp.unit())).unit ();
    1689     xprime = yprime.cross (new_up);
    1690     // Projection of vp on plane perpendicular to up...
    1691     a1 = sinalpha * xprime;
    1692     // Required new projection...
    1693     a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
    1694     // Required Increment vector...
    1695     delta = a2 - a1;
    1696     // So new viewpoint is...
    1697     viewPoint = new_vp.unit() + delta;
    1698    
     1668  //phi spin stuff here
     1669 
     1670  vp = fVP.GetViewpointDirection ().unit ();
     1671  up = fVP.GetUpVector ().unit ();
     1672 
     1673  yprime = (up.cross(vp)).unit();
     1674  zprime = (vp.cross(yprime)).unit();
     1675 
     1676  if (fVP.GetLightsMoveWithCamera()) {
     1677    delta_alpha = dy * fDeltaRotation;
     1678    delta_theta = -dx * fDeltaRotation;
     1679  } else {
     1680    delta_alpha = -dy * fDeltaRotation;
     1681    delta_theta = dx * fDeltaRotation;
     1682  }   
     1683 
     1684  delta_alpha *= deg;
     1685  delta_theta *= deg;
     1686 
     1687  new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
     1688 
     1689  // to avoid z rotation flipping
     1690  // to allow more than 360° rotation
     1691  if (fVP.GetLightsMoveWithCamera()) {
     1692    new_up = (new_vp.cross(yprime)).unit();
     1693    if (new_vp.z()*vp.z() <0) {
     1694      new_up.set(new_up.x(),-new_up.y(),new_up.z());
     1695    }
     1696  } else {
     1697    new_up = up;
     1698    if (new_vp.z()*vp.z() <0) {
     1699      new_up.set(new_up.x(),-new_up.y(),new_up.z());
     1700    }
     1701  }
     1702  fVP.SetUpVector(new_up);
     1703  ////////////////
     1704  // Rotates by fixed azimuthal angle delta_theta.
     1705 
     1706  cosalpha = new_up.dot (new_vp.unit());
     1707  sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
     1708  yprime = (new_up.cross (new_vp.unit())).unit ();
     1709  xprime = yprime.cross (new_up);
     1710  // Projection of vp on plane perpendicular to up...
     1711  a1 = sinalpha * xprime;
     1712  // Required new projection...
     1713  a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
     1714  // Required Increment vector...
     1715  delta = a2 - a1;
     1716  // So new viewpoint is...
     1717  viewPoint = new_vp.unit() + delta;
     1718 
    16991719#ifdef GEANT4_QT_DEBUG
    1700 //      printf("vp Vector : %f %f %f delta_alpha:%f delta_theta:%f cosalpha:%f sinalpha:%f\n",viewPoint.x(),viewPoint.y(),viewPoint.z(),delta_alpha,delta_theta,cosalpha,sinalpha);
    1701 //      printf("up : %f %f %f\n",up.x(),up.y(),up.z());
    1702 //      printf("new up : %f %f %f\n",new_up.x(),new_up.y(),new_up.z());
    1703 //      printf("vp : %f %f %f\n",vp.x(),vp.y(),vp.z());
    1704 //      printf("new_vp : %f %f %f\n",new_vp.x(),new_vp.y(),new_vp.z());
    1705 #endif
    1706     fVP.SetViewAndLights (viewPoint);
    1707     updateQWidget();
    1708    
    1709     if (fAutoMove)
    1710       ((QApplication*)G4Qt::getInstance ())->processEvents();
    1711   }
     1720  //      printf("vp Vector : %f %f %f delta_alpha:%f delta_theta:%f cosalpha:%f sinalpha:%f\n",viewPoint.x(),viewPoint.y(),viewPoint.z(),delta_alpha,delta_theta,cosalpha,sinalpha);
     1721  //      printf("up : %f %f %f\n",up.x(),up.y(),up.z());
     1722  //      printf("new up : %f %f %f\n",new_up.x(),new_up.y(),new_up.z());
     1723  //      printf("vp : %f %f %f\n",vp.x(),vp.y(),vp.z());
     1724  //      printf("new_vp : %f %f %f\n",new_vp.x(),new_vp.y(),new_vp.z());
     1725#endif
     1726  fVP.SetViewAndLights (viewPoint);
     1727  updateQWidget();
    17121728 
    17131729  fHoldRotateEvent = false;
     1730#ifdef GEANT4_QT_DEBUG
     1731  printf("G4OpenGLQtViewer::Rotate END\n");
     1732#endif
    17141733}
    17151734

  • trunk/geant4/visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc

    r790 r797  
    3434#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
    3535
    36 //#define GEANT4_QT_DEBUG
     36#define GEANT4_QT_DEBUG
    3737
    3838#include "G4OpenGLStoredQtViewer.hh"
    … …  
    158158
    159159  } else {
    160 #ifdef GEANT4_QT_DEBUG
    161     printf("***************************  CASE 1 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n");
    162 #endif
    163160     
    164161    // If kernel visit was needed, drawing and FinishView will already
    … …  
    166163    if (!kernelVisitWasNeeded) {
    167164#ifdef GEANT4_QT_DEBUG
    168       printf("***************************  CASE 2 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n");
     165      printf("**************************  G4OpenGLStoredQtViewer::DrawView Don't need kernel Visit \n");
    169166#endif
    170167      DrawDisplayLists ();
    … …  
    172169    } else {
    173170#ifdef GEANT4_QT_DEBUG
    174       printf("***************************  CASE 3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n");
     171      printf("**************************  G4OpenGLStoredQtViewer::DrawView need kernel Visit \n");
    175172#endif
    176173      // However, union cutaways are implemented in DrawDisplayLists, so make
    … …  
    208205//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
    209206{
    210 #ifdef GEANT4_QT_DEBUG
    211   printf("G4OpenGLStoredQtViewer::FinishView VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV\n");
    212 #endif
    213 
    214207  glFlush ();
    215208  swapBuffers ();
    216 #ifdef GEANT4_QT_DEBUG
    217   printf("G4OpenGLStoredQtViewer::FinishView ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n");
    218 #endif
    219 
    220209}
    221210
    … …  
    314303#endif
    315304    setMouseTracking(true);
    316     G4MousePressEvent(event->pos(),Qt::LeftButton);
     305    G4MousePressEvent(event->pos());
    317306  }
    318307}
    … …  
    338327void G4OpenGLStoredQtViewer::mouseReleaseEvent(QMouseEvent *event)
    339328{
    340 #ifdef GEANT4_QT_DEBUG
    341   printf("G4OpenGLStoredQtViewer::mouseReleaseEvent\n");
     329  G4MouseReleaseEvent();
     330#ifdef GEANT4_QT_DEBUG
     331  printf("G4OpenGLStoredQtViewer::mouseReleaseEvent ================\n");
    342332#endif
    343333  setMouseTracking(false);
    … …  
    352342  G4MouseMoveEvent(event->x(),event->y(),event->buttons());
    353343#endif
    354   if (hasPendingEvents ())
    355 #if QT_VERSION < 0x040000
    356     G4MouseMoveEvent(event->x(),event->y(),event->state());
    357 #else
    358     G4MouseMoveEvent(event->x(),event->y(),event->buttons());
    359 #endif
    360344}
    361345
Note: See TracChangeset for help on using the changeset viewer.