?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / Contrib / Manipulators / OSGManipulator.cpp
blob2945cf29d6dc4c3f80dd87fcc30218d6440f509d
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 "OSGBaseFunctions.h"
50 #include "OSGSimpleMaterial.h"
51 #include "OSGTransform.h"
52 #include "OSGGeometry.h"
53 #include "OSGSimpleGeometry.h"
54 #include "OSGWindow.h"
55 #include "OSGNameAttachment.h"
56 #include "OSGCamera.h"
57 #include "OSGViewport.h"
58
59 #include "OSGManipulator.h"
60 #include "OSGSimpleGeometryExt.h"
61
62 OSG_USING_NAMESPACE
63
64 /***************************************************************************\
65 * Description *
66 \***************************************************************************/
67
68 /*! \class OSG::Manipulator
69 Baseclass for all Manipulators
70 */
71
72 /***************************************************************************\
73 * Class variables *
74 \***************************************************************************/
75
76 /***************************************************************************\
77 * Class methods *
78 \***************************************************************************/
79
80 //! initialize the static features of the class, e.g. action callbacks
81
82 void Manipulator::initMethod(InitPhase)
83 {
84 }
85
86 /***************************************************************************\
87 * Instance methods *
88 \***************************************************************************/
89
90 /*-------------------------------------------------------------------------*\
91 - private -
92 \*-------------------------------------------------------------------------*/
93
94 /*----------------------- constructors & destructors ----------------------*/
95
96 Manipulator::Manipulator(void) :
97 Inherited ( ),
98 _activeParent (NULL),
99 _externalUpdateHandler(NULL)
100 {
101 }
102
103 Manipulator::Manipulator(const Manipulator &source) :
104 Inherited (source),
105 _activeParent (NULL ),
106 _externalUpdateHandler(NULL )
107 {
108 //TODO: empty copy constructor?!?!?!?
109 }
110
111 Manipulator::~Manipulator(void)
112 {
113 }
114
115 /*----------------------------- class specific ----------------------------*/
116
117 void Manipulator::setExternalUpdateHandler(ExternalUpdateHandler* h)
118 {
119 _externalUpdateHandler = h;
120 }
121
122 void Manipulator::callExternalUpdateHandler()
123 {
124 if ( NULL != _externalUpdateHandler )
125 {
126 _externalUpdateHandler->update(this->getTarget());
127 }
128 }
129
130 //! react to field changes
131
132 void Manipulator::changed(ConstFieldMaskArg whichField,
133 UInt32 origin,
134 BitVector details )
135 {
136 Inherited::changed(whichField, origin, details);
137
138 if ( (whichField & TargetFieldMask) == TargetFieldMask )
139 {
140 updateHandleTransform();
141 }
142 if ( (whichField & ParentsFieldMask) == ParentsFieldMask )
143 {
144 Node *parent;
145
146 if ( !getParents().empty() )
147 {
148 //std::cout << "parent size= " << parents.getSize() << std::endl;
149 parent = dynamic_cast<Node *>(getParents()[0]); // Dangerous! multiple parents?
150 }
151 else
152 {
153 parent = NULL;
154 }
155
156 //std::cout << " Parent= " << parent << std::endl;
157 //std::cout << " activeParent= " << _activeParent << std::endl;
158
159 if ( parent != _activeParent )
160 {
161 if ( NULL != parent )
162 {
163 // remove old childs from a loaded osb file.
164 while(parent->getNChildren() > 0)
165 {
166 parent->subChild(parent->getChild(0));
167 }
168 addHandleGeo(parent);
169 }
170
171 if ( _activeParent != NULL )
172 {
173 subHandleGeo(_activeParent);
174 }
175
176 _activeParent = parent;
177 }
178 }
179 if ( (whichField & EnablePivotFieldMask) == EnablePivotFieldMask )
180 {
181 if (getPivotNode() != 0) // Some manips don't support a pivot and don't create a node for it
182 {
183 if (!getEnablePivot())
184 {
185 getPivotNode()->setTravMask(0x0);
186 }
187 else
188 {
189 getPivotNode()->setTravMask(0xffffffff);
190 }
191 }
192 }
193
194 }
195
196 void Manipulator::addHandleGeo(Node *n)
197 {
198 n->addChild(getTransXNode());
199 n->addChild(getTransYNode());
200 n->addChild(getTransZNode());
201 n->addChild(getAxisLinesN());
202 n->addChild(getPivotNode());
203 }
204
205 void Manipulator::subHandleGeo(Node *n)
206 {
207 n->subChild(getTransXNode());
208 n->subChild(getTransYNode());
209 n->subChild(getTransZNode());
210 n->subChild(getAxisLinesN());
211 n->subChild(getPivotNode());
212 }
213
214 void Manipulator::updateHandleTransform()
215 {
216 if ( getTarget() != NULL )
217 {
218 Transform *t = dynamic_cast<Transform *>(getTarget()->getCore());
219 Matrix m,o;
220
221 Vec3f translation;
222 Quaternion rotation;
223 Vec3f scaleFactor;
224 Quaternion scaleOrientation;
225
226 m = t->getMatrix();
227 m.getTransform(translation, rotation, scaleFactor, scaleOrientation);
228
229 if( false == o.invertFrom(m) )
230 {
231 SWARNING << "Matrix is SINGULAR!!!\n";
232 }
233 else
234 {
235 Matrix n,ma,mb,mc,md;
236
237 mb.setTranslate(translation);
238 ma.setTranslate(Vec3f(getPivot()[0] * scaleFactor[0],
239 getPivot()[1] * scaleFactor[1],
240 getPivot()[2] * scaleFactor[2])
241 );
242 mc.setRotate(rotation);
243
244 n.multLeft(ma);
245 n.multLeft(mc);
246 n.multLeft(mb);
247 n.multLeft(o);
248
249 setMatrix(n);
250 }
251 }
252 }
253
254 //! output the instance for debug purposes
255
256 void Manipulator::dump( UInt32 ,
257 const BitVector ) const
258 {
259 SLOG << "Dump Manipulator NI" << std::endl;
260 }
261
262 void Manipulator::onCreate()
263 {
264 }
265
266 void Manipulator::onCreate(const Manipulator* source)
267 {
268 Inherited::onCreate(source);
269
270 SimpleMaterialUnrecPtr pMat;
271
272 // SimpleMaterial *simpleMat;
273 Geometry *geo;
274
275 setExternalUpdateHandler(NULL);
276
277 // add a name attachment
278 NameUnrecPtr nameN = Name::create();
279 nameN->editFieldPtr()->setValue("XManipulator");
280 addAttachment(nameN);
281
282 // make the axis lines
283 NodeUnrecPtr pNode = makeCoordAxis(getLength()[0], 2.0, false);
284 setAxisLinesN(pNode);
285
286 // make the red x-axis transform and handle
287
288 pNode = Node::create();
289 setTransXNode(pNode);
290 OSG::ComponentTransformUnrecPtr transHandleXC = ComponentTransform::create();
291
292 pNode = makeHandleGeo();
293 setHandleXNode(pNode);
294 pMat = SimpleMaterial::create();
295 setMaterialX (pMat );
296
297 getTransXNode()->setCore (transHandleXC );
298 getTransXNode()->addChild(getHandleXNode());
299
300 transHandleXC->setTranslation(Vec3f(getLength()[0], 0, 0) );
301 transHandleXC->setRotation (Quaternion(Vec3f(0, 0, 1), osgDegree2Rad(-90)));
302
303 pMat->setDiffuse(Color3f(1, 0, 0));
304 pMat->setLit (true );
305
306 geo = dynamic_cast<Geometry *>(getHandleXNode()->getCore());
307 geo->setMaterial(pMat);
308
309 //
310 // make the green y-axis transform and handle
311
312 pNode = Node::create();
313 setTransYNode(pNode);
314 OSG::ComponentTransformUnrecPtr transHandleYC = ComponentTransform::create();
315 pNode = makeHandleGeo();
316 setHandleYNode(pNode);
317 pMat = SimpleMaterial::create();
318 setMaterialY(pMat);
319
320 getTransYNode()->setCore (transHandleYC );
321 getTransYNode()->addChild(getHandleYNode());
322
323 transHandleYC->setTranslation(Vec3f(0, getLength()[1], 0) );
324 // transHandleYC->setRotation ( Quaternion(Vec3f(0, 0, 1), osgDegree2Rad(-90)));
325
326 pMat->setDiffuse(Color3f(0, 1, 0));
327 pMat->setLit (true );
328
329 geo = dynamic_cast<Geometry *>(getHandleYNode()->getCore());
330 geo->setMaterial(pMat);
331
332 //
333 // make the blue z-axis transform and handle
334
335 pNode = Node::create();
336 setTransZNode(pNode);
337 OSG::ComponentTransformUnrecPtr transHandleZC = ComponentTransform::create();
338 pNode = makeHandleGeo();
339 setHandleZNode(pNode);
340 pMat = SimpleMaterial::create();
341 setMaterialZ (pMat);
342
343 getTransZNode()->setCore (transHandleZC );
344 getTransZNode()->addChild(getHandleZNode());
345
346 transHandleZC->setTranslation(Vec3f(0, 0, getLength()[2]) );
347 transHandleZC->setRotation (Quaternion(Vec3f(1, 0, 0), osgDegree2Rad(90)));
348
349 pMat->setDiffuse(Color3f(0, 0, 1));
350 pMat->setLit (true );
351
352 geo = dynamic_cast<Geometry *>(getHandleZNode()->getCore());
353 geo->setMaterial(pMat);
354
355 //
356 // make the yellow pivot transform and handle
357
358 pNode = Node::create();
359 setPivotNode(pNode);
360 OSG::ComponentTransformUnrecPtr transHandlePivotC = ComponentTransform::create();
361 pNode = makeSphere(2, 0.05f);
362 setHandlePNode(pNode);
363 pMat = SimpleMaterial::create();
364 setMaterialPivot (pMat);
365
366 getPivotNode()->setCore (transHandlePivotC );
367 getPivotNode()->addChild(getHandlePNode());
368
369 transHandlePivotC->setTranslation(Vec3f(0, 0, 0));
370
371 pMat->setDiffuse(Color3f(1, 1, 0));
372 pMat->setLit (true );
373
374 geo = dynamic_cast<Geometry *>(getHandlePNode()->getCore());
375 geo->setMaterial(pMat);
376
377 if (!getEnablePivot())
378 {
379 getPivotNode()->setTravMask(0x0);
380 }
381
382 commitChanges();
383 }
384
385 void Manipulator::onDestroy()
386 {
387 }
388
389 void Manipulator::resolveLinks(void)
390 {
391 Inherited::resolveLinks();
392
393 _activeParent = NULL;
394 }
395
396 Pnt2f Manipulator::calcScreenProjection(const Pnt3f & p,
397 Viewport * const port)
398 {
399 Camera *cam;
400 Matrix proj, projtrans, view;
401 Pnt3f pnt;
402
403 if( port != NULL )
404 {
405 cam = port->getCamera();
406
407 cam->getProjection(proj,
408 port->calcPixelWidth(),
409 port->calcPixelHeight());
410 cam->getProjectionTranslation(projtrans,
411 port->calcPixelWidth(),
412 port->calcPixelHeight());
413 cam->getViewing(view,
414 port->calcPixelWidth(),
415 port->calcPixelHeight());
416
417 Matrix wctocc = proj;
418 wctocc.mult(projtrans);
419 wctocc.mult(view);
420
421 wctocc.multFull(p, pnt);
422
423 Real32 rx = (pnt[0] + 1.0) /2 * port->calcPixelWidth();
424 Real32 ry = (pnt[1] + 1.0) /2 * port->calcPixelHeight();
425
426 return Pnt2f(rx, ry);
427 }
428 else
429 {
430 SWARNING << "calcScreenProjection(const Pnt3f&, "
431 "Viewport * const port="
432 << port << ")\n";
433 return Pnt2f(0.0f, 0.0f);
434 }
435 }
436
437 /*! The mouseMove is called by the viewer when the mouse is moved in the
438 viewer and this handle is the active one.
439
440 \param x the x-pos of the mouse (pixel)
441 \param y the y-pos of the mouse (pixel)
442 */
443 void Manipulator::mouseMove(const Int16 x,
444 const Int16 y)
445 {
446 //SLOG << "Manipulator::mouseMove() enter\n" << std::flush;
447
448 // get the beacon's core (must be ComponentTransform) and it's center
449 if( getTarget() != NULL )
450 {
451 // get transformation of beacon
452 Transform *t = dynamic_cast<Transform *>(getTarget()->getCore());
453
454 if( t != NULL )
455 {
456 UInt16 coord(0); // active coordinate: X=0, Y=1, Z=2
457
458 Int16 xDiff; // the mousepos x delta
459 Int16 yDiff; // the mousepos y delta
460
461 Vec3f centerV; // center of beacon
462 Vec3f handleCenterV; // center of subhandle
463 Vec2f mouseScreenV; // mouse move vector
464 Vec2f handleScreenV; // handle vec in (cc)
465 Real32 handleScreenVLen; // len of handle vec in (cc)
466
467 Vec3f translation; // for matrix decomposition
468 Quaternion rotation;
469 Vec3f scaleFactor;
470 Quaternion scaleOrientation;
471
472 // TODO: das ist ja schon ein wenig haesslich
473 static const Vec3f coordVector[3] = {
474 Vec3f(1.0f, 0.0f, 0.0f),
475 Vec3f(0.0f, 1.0f, 0.0f),
476 Vec3f(0.0f, 0.0f, 1.0f)
477 };
478
479 // check for the active handle
480 if( getActiveSubHandle() == getHandleXNode())
481 {
482 coord = 0;
483 }
484 else if(getActiveSubHandle() == getHandleYNode())
485 {
486 coord = 1;
487 }
488 else if(getActiveSubHandle() == getHandleZNode())
489 {
490 coord = 2;
491 }
492
493 // TODO: only for debugging, -> FDEBUG
494 //SLOG << "moving " << ( coord == 0 ? "x\n" :
495 // coord == 1 ? "y\n" :
496 // "z\n" )
497 // << std::flush;
498
499 // calculate diffs between current and last mouse position
500 xDiff = x - Int16(getLastMousePos()[0]);
501 yDiff = y - Int16(getLastMousePos()[1]);
502
503 // set the vector resulting from user mouse movement and calc its length
504 mouseScreenV.setValues(xDiff, -yDiff);
505
506 t->getMatrix().getTransform(translation, rotation, scaleFactor,
507 scaleOrientation);
508
509
510 // calculate the camera coordinate of the center
511 centerV = translation;
512 Pnt2f centerPixPos = calcScreenProjection(centerV.addToZero(),
513 getViewport());
514
515
516 // calculate the camera coordinate of the handle center
517 handleCenterV = centerV + coordVector[coord]*getLength()[coord];
518 Pnt2f handleCenterPixPos = calcScreenProjection(handleCenterV.addToZero(),
519 getViewport());
520
521 handleScreenV = handleCenterPixPos - centerPixPos;
522 handleScreenVLen = handleScreenV.length();
523
524 Real32 s = handleScreenV.dot(mouseScreenV) / handleScreenVLen;
525
526 doMovement(t, coord, s * getLength()[coord] * 0.01, translation,
527 rotation, scaleFactor, scaleOrientation);
528 }
529 else
530 {
531 SWARNING << "handled object has no parent transform!\n";
532 }
533 callExternalUpdateHandler();
534 }
535 else
536 {
537 SWARNING << "Handle has no target.\n";
538 }
539
540 setLastMousePos(Pnt2f(Real32(x), Real32(y)));
541 updateHandleTransform();
542
543 //SLOG << "Manipulator::mouseMove() leave\n" << std::flush;
544 }
545
546 /*! The mouseButtonPress is called by the viewer when the mouse is
547 pressed in the viewer above a subhandle of this handle.
548
549 \param button the button pressed
550 \param x the x-pos of the mouse (pixel)
551 \param y the y-pos of the mouse (pixel)
552 */
553
554 void Manipulator::mouseButtonPress(const UInt16 button,
555 const Int16 x,
556 const Int16 y )
557 {
558 setLastMousePos(Pnt2f(Real32(x), Real32(y)));
559 setActive(true);
560 }
561
562 void Manipulator::mouseButtonRelease(const UInt16 button,
563 const Int16 x,
564 const Int16 y )
565 {
566 setActive(false);
567 }
568
569 void Manipulator::doMovement( Transform *t,
570 const Int32 coord,
571 const Real32 value,
572 const Vec3f &translation,
573 const Quaternion &rotation,
574 const Vec3f &scaleFactor,
575 const Quaternion &scaleOrientation)
576 {
577 SWARNING << "MoveManipulator::doMovement: called. Shouldn't happen!" << endLog;
578 }
579
580 const Vec3f& Manipulator::getActiveAxis(void) const
581 {
582 static const Vec3f coordVector[] = {
583 Vec3f(1.0f, 0.0f, 0.0f),
584 Vec3f(0.0f, 1.0f, 0.0f),
585 Vec3f(0.0f, 0.0f, 1.0f),
586 Vec3f(-1.0f, -1.0f, -1.0f)
587 };
588
589 UInt16 coord;
590 // check for the active handle
591 if( getActiveSubHandle() == getHandleXNode())
592 {
593 coord = 0;
594 }
595 else if(getActiveSubHandle() == getHandleYNode())
596 {
597 coord = 1;
598 }
599 else if(getActiveSubHandle() == getHandleZNode())
600 {
601 coord = 2;
602 }
603 else
604 {
605 coord = 3;
606 }
607
608 return coordVector[coord];
609 }