Source/Contrib/Manipulators/OSGPlaneMoveManipulator.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2002 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45
  46 #define OSG_COMPILEMANIPULATORSLIB
  47
  48 #include "OSGConfig.h"
  49 #include "OSGPlane.h"
  50 #include "OSGRenderAction.h"
  51 #include "OSGIntersectAction.h"
  52 #include "OSGSimpleMaterial.h"
  53 #include "OSGNameAttachment.h"
  54 #include "OSGGeoBuilder.h"
  55 #include "OSGLineChunk.h"
  56 #include "OSGCamera.h"
  57
  58 #include "OSGPlaneMoveManipulator.h"
  59
  60 OSG_USING_NAMESPACE
  61
  62 /***************************************************************************\
  63  *                            Description                                  *
  64 \***************************************************************************/
  65
  66 /*! \class OSG::PlaneMoveManipulator
  67  * The MoveHandle is used for moving objects. It consist of three axis which
  68  * can be picked and translated and one center box to translate freely in 3D.
  69  */
  70
  71 /***************************************************************************\
  72  *                           Class variables                               *
  73 \***************************************************************************/
  74
  75 /***************************************************************************\
  76  *                           Class methods                                 *
  77 \***************************************************************************/
  78
  79 void PlaneMoveManipulator::initMethod(InitPhase ePhase)
  80 {
  81     Inherited::initMethod(ePhase);
  82
  83     if(ePhase == TypeObject::SystemPost)
  84     {
  85         IntersectAction::registerEnterDefault(
  86             getClassType(),
  87             reinterpret_cast<Action::Callback>(
  88                 &PlaneMoveManipulator::intersectEnter));
  89
  90         IntersectAction::registerLeaveDefault(
  91             getClassType(),
  92             reinterpret_cast<Action::Callback>(
  93                 &PlaneMoveManipulator::intersectLeave));
  94
  95         RenderAction::registerEnterDefault(
  96             getClassType(),
  97             reinterpret_cast<Action::Callback>(
  98                 &PlaneMoveManipulator::renderEnter));
  99
 100         RenderAction::registerLeaveDefault(
 101             getClassType(),
 102             reinterpret_cast<Action::Callback>(
 103                 &PlaneMoveManipulator::renderLeave));
 104     }
 105 }
 106
 107
 108 /***************************************************************************\
 109  *                           Instance methods                              *
 110 \***************************************************************************/
 111
 112 /*-------------------------------------------------------------------------*\
 113  -  private                                                                 -
 114 \*-------------------------------------------------------------------------*/
 115
 116 /*----------------------- constructors & destructors ----------------------*/
 117
 118 PlaneMoveManipulator::PlaneMoveManipulator(void) :
 119     Inherited()
 120 {
 121 }
 122
 123 PlaneMoveManipulator::PlaneMoveManipulator(const PlaneMoveManipulator &source) :
 124     Inherited(source)
 125 {
 126 }
 127
 128 PlaneMoveManipulator::~PlaneMoveManipulator(void)
 129 {
 130 }
 131
 132 void PlaneMoveManipulator::onCreate()
 133 {
 134 }
 135
 136 void PlaneMoveManipulator::onCreate(const PlaneMoveManipulator* source)
 137 {
 138     // Skip direct parent, don't want the default geometry creation
 139     Transform::onCreate(source);
 140
 141     SimpleMaterialUnrecPtr pMat = SimpleMaterial::create();
 142     pMat->setDiffuse(Color3f(.5, .5, .5));
 143     pMat->setLit    (false              );
 144     setMaterialX(pMat);
 145
 146     pMat = SimpleMaterial::create();
 147     pMat->setDiffuse(Color3f(0, 1, 0));
 148     pMat->setLit    (false           );
 149     LineChunkUnrecPtr lc = LineChunk::create();
 150     lc->setWidth(3);
 151     pMat->addChunk(lc);
 152     setMaterialY(pMat);
 153
 154     pMat = SimpleMaterial::create();
 155     pMat->setDiffuse(Color3f(0., 0., 1.));
 156     pMat->setLit    (true               );
 157     setMaterialZ(pMat);
 158
 159 //    SimpleMaterial *simpleMat;
 160 //    Geometry       *geo;
 161
 162     setExternalUpdateHandler(NULL);
 163
 164     // add a name attachment
 165     NameUnrecPtr nameN = Name::create();
 166     nameN->editFieldPtr()->setValue("XYManipulator");
 167     addAttachment(nameN);
 168
 169     // make the axis line. Not really a handle, but easier to manage this way.
 170
 171     GeoBuilder b;
 172
 173     b.vertex(Pnt3f(0,0,0));
 174     b.vertex(Pnt3f(0,getLength()[1],0));
 175
 176     b.line(0, 1);
 177
 178     GeometryUnrecPtr g = b.getGeometry();
 179
 180     g->setMaterial(getMaterialY());
 181
 182     NodeUnrecPtr pNode = makeNodeFor(g);
 183     setTransYNode(pNode);
 184
 185     // make the plane handle
 186
 187     pNode = Node::create();
 188     setTransXNode(pNode);
 189
 190     g = makePlaneGeo(getLength()[0] / 2.f, getLength()[2] / 2.f, 1, 1);
 191     g->setMaterial(getMaterialX());
 192     pNode = makeNodeFor(g);
 193
 194     OSG::ComponentTransformUnrecPtr transHandleXC = ComponentTransform::create();
 195
 196     setHandleXNode(pNode);
 197
 198     getTransXNode()->setCore (transHandleXC   );
 199     getTransXNode()->addChild(getHandleXNode());
 200
 201     transHandleXC->setTranslation(Vec3f(0, getLength()[1], 0));
 202     transHandleXC->setRotation   (Quaternion(Vec3f(1, 0, 0), osgDegree2Rad(90)));
 203
 204     //
 205     // make the rotate handle
 206
 207     pNode = Node::create();
 208     setTransZNode(pNode);
 209
 210     g = makeCylinderGeo(0.05f, 0.1f, 16, true, true, true);
 211     g->setMaterial(getMaterialZ());
 212     pNode = makeNodeFor(g);
 213
 214     OSG::ComponentTransformUnrecPtr transHandleZC = ComponentTransform::create();
 215
 216     setHandleZNode(pNode);
 217
 218     getTransZNode()->setCore (transHandleZC   );
 219     getTransZNode()->addChild(getHandleZNode());
 220
 221     transHandleZC->setTranslation(Vec3f(0, getLength()[1], 0));
 222
 223     commitChanges();
 224 }
 225
 226 /*----------------------------- class specific ----------------------------*/
 227
 228 void PlaneMoveManipulator::changed(ConstFieldMaskArg whichField,
 229                               UInt32            origin,
 230                               BitVector         details)
 231 {
 232     Inherited::changed(whichField, origin, details);
 233 }
 234
 235 void PlaneMoveManipulator::dump(      UInt32    uiIndent,
 236                            const BitVector bvFlags ) const
 237 {
 238     Inherited::dump(uiIndent, bvFlags);
 239 }
 240
 241 NodeTransitPtr PlaneMoveManipulator::makeHandleGeo()
 242 {
 243     return Node::create();
 244 }
 245
 246 /*! The mouseMove is called by the viewer when the mouse is moved in the
 247     viewer and this handle is the active one.
 248
 249     \param x the x-pos of the mouse (pixel)
 250     \param y the y-pos of the mouse (pixel)
 251  */
 252 void PlaneMoveManipulator::mouseMove(const Int16 x,
 253                             const Int16 y)
 254 {
 255     SLOG << "==============================" << endLog;
 256     SLOG << "PlaneMoveManipulator::mouseMove() enter x=" << x << " y=" << y << endLog;
 257
 258     // get the beacon's core (must be ComponentTransform) and it's center
 259     if( getTarget() == NULL )
 260     {
 261         SWARNING << "Handle has no target.\n";
 262         return;
 263
 264     }
 265     // get transformation of beacon
 266     Transform *t = dynamic_cast<Transform *>(getTarget()->getCore());
 267
 268     if( t == NULL )
 269     {
 270         SWARNING << "handled object has no parent transform!\n";
 271         return;
 272     }
 273
 274     Vec3f      translation;       // for matrix decomposition
 275     Quaternion rotation;
 276     Vec3f      scaleFactor;
 277     Quaternion scaleOrientation;
 278
 279     t->getMatrix().getTransform(translation, rotation, scaleFactor,
 280                                 scaleOrientation);
 281
 282     OSG::Line viewray;
 283     getViewport()->getCamera()->calcViewRay(viewray, x, y, *getViewport());
 284
 285     SLOG << "Manipulator::mouseMove(): viewray: " << viewray << endLog;
 286
 287     // Get manipulator axes into world space
 288     OSG::Matrix tm = getTarget()->getToWorld();
 289
 290     Vec3f rot_axis;
 291     tm.multFull(Vec3f(0,1,0), rot_axis);
 292
 293     Plane pl(rot_axis, getClickPoint());
 294
 295     Pnt3f plpoint;
 296
 297     if (pl.intersect(viewray, plpoint) == true) // Ignore moving out of the plane...
 298     {
 299         SLOG << "Manipulator::mouseMove(): plpoint: " << plpoint << endLog;
 300
 301         Vec3f      trans = getBaseTranslation();
 302         Quaternion rot   = getBaseRotation();
 303
 304         // Get manipulator axes into world space
 305         Vec3f xp,zp;
 306
 307         tm.multFull(Vec3f(1,0,0), xp);
 308         tm.multFull(Vec3f(0,0,1), zp);
 309
 310         if (getActiveSubHandle() == getHandleXNode())
 311         {
 312             Line xaxis(getClickPoint(), xp);
 313             Line zaxis(getClickPoint(), zp);
 314
 315             Real32 fx = xaxis.getClosestPointT(plpoint);
 316             Real32 fz = zaxis.getClosestPointT(plpoint);
 317
 318             SLOG << "Manipulator::mouseMove(): xaxis: " << xaxis << " zaxis: " << zaxis <<endLog;
 319             SLOG << "Manipulator::mouseMove(): fx: " << fx << " fz: " << fz <<endLog;
 320
 321             // Alternative: transform hitpoint into manip space
 322             OSG::Matrix m = getTarget()->getToWorld();
 323             m.invert();
 324
 325             Pnt3f mpoint;
 326             m.mult(plpoint, mpoint);
 327
 328             SLOG << "Manipulator::mouseMove(): mpoint:" << mpoint << endLog;
 329
 330             trans = trans + xp * fx + zp * fz;
 331         }
 332         else if (getActiveSubHandle() == getHandleZNode())
 333         {
 334             Pnt3f wcenter;
 335
 336             tm.multFull(Pnt3f(0,getLength()[1],0), wcenter);
 337
 338             Vec3f vclick, vcurrent;
 339
 340             vclick = getClickPoint() - wcenter;
 341             vcurrent = plpoint - wcenter;
 342
 343             vclick.normalize();
 344             vcurrent.normalize();
 345
 346             Real32 a = vclick.enclosedAngle(vcurrent);
 347
 348             SLOG << "Manipulator::mouseMove(): wcenter:" << wcenter << "" <<endLog;
 349             SLOG << "Manipulator::mouseMove(): vclick:" << vclick << " vcurrent:" << vcurrent <<endLog;
 350             SLOG << "Manipulator::mouseMove(): angle:" << a << " deg: " << osgRad2Degree(a) << endLog;
 351         }
 352
 353         Matrix m;
 354
 355         m.setTransform(trans, rot, scaleFactor, scaleOrientation);
 356
 357         t->setMatrix(m);
 358
 359     }
 360
 361     setLastMousePos(Pnt2f(Real32(x), Real32(y)));
 362     updateHandleTransform();
 363
 364     //SLOG << "Manipulator::mouseMove() leave\n" << std::flush;
 365 }
 366
 367 /*! The mouseButtonPress is called by the viewer when the mouse is
 368     pressed in the viewer above a subhandle of this handle.
 369
 370     \param button the button pressed
 371     \param x the x-pos of the mouse (pixel)
 372     \param y the y-pos of the mouse (pixel)
 373  */
 374
 375 void PlaneMoveManipulator::mouseButtonPress(const UInt16 button,
 376                                    const Int16  x,
 377                                    const Int16  y     )
 378 {
 379     Transform *t = dynamic_cast<Transform *>(getTarget()->getCore());
 380
 381     if (t == NULL)
 382     {
 383         SWARNING << "PlaneMoveManipulator::mouseButtonPress() target is not a Transform!" << endLog;
 384         return;
 385     }
 386
 387     SLOG << "PlaneMoveManipulator::mouseButtonPress() button=" << button << " x=" << x << " y=" << y  << std::endl << endLog;
 388
 389     OSG::Line viewray;
 390     getViewport()->getCamera()->calcViewRay(viewray, x, y, *getViewport());
 391
 392     OSG::Node *scene = getTarget();
 393     while (scene->getParent() != 0)
 394     {
 395         scene = scene->getParent();
 396     }
 397
 398     OSG::IntersectActionRefPtr act = OSG::IntersectAction::create();
 399     act->setLine( viewray );
 400     act->apply( scene );
 401
 402     SLOG << "PlaneMoveManipulator::mouseButtonPress() viewray=" << viewray << " scene=" << scene << endLog;
 403
 404     if ( act->didHit() )
 405     {
 406         SLOG << "PlaneMoveManipulator::mouseButtonPress() hit! at " << act->getHitPoint() << endLog;
 407
 408         // Get manipulator plane into world space
 409         OSG::Matrix m = getTarget()->getToWorld();
 410
 411         Vec3f      translation;       // for matrix decomposition
 412         Quaternion rotation;
 413         Vec3f      scaleFactor;
 414         Quaternion scaleOrientation;
 415
 416         t->getMatrix().getTransform(translation, rotation, scaleFactor,
 417                                     scaleOrientation);
 418
 419         Vec3f rot_axis;
 420         rotation.multVec(Vec3f(0,1,0), rot_axis);
 421
 422         Plane pl(rot_axis, act->getHitPoint());
 423
 424         SLOG << "PlaneMoveManipulator::mouseButtonPress() world plane: " << pl << endLog;
 425
 426         setClickPoint(act->getHitPoint());
 427
 428         setBaseTranslation(translation);
 429         setBaseRotation(rotation);
 430
 431         setActive(true);
 432     }
 433
 434     act = NULL;
 435 }
 436
 437 void PlaneMoveManipulator::mouseButtonRelease(const UInt16 button,
 438                                      const Int16  x,
 439                                      const Int16  y     )
 440 {
 441     //SLOG << "Manipulator::mouseButtonRelease() button=" << button << " x=" << x << " y=" << y  << std::endl << endLog;
 442     setActive(false);
 443 }