Source/System/NodeCores/Groups/Misc/OSGDoubleTransform.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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 <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGGL.h"
  49
  50 #include "OSGIntersectAction.h"
  51
  52 #include "OSGRenderAction.h"
  53
  54 #ifdef OSG_HAVE_ACTION //CHECK
  55 #include "OSGIntersectActor.h"
  56 #endif
  57
  58 #include "OSGDoubleTransform.h"
  59 #include "OSGVolume.h"
  60
  61 OSG_BEGIN_NAMESPACE
  62
  63 // Documentation for this class is emitted in the
  64 // OSGDoubleTransformBase.cpp file.
  65 // To modify it, please change the .fcd file (OSGDoubleTransform.fcd) and
  66 // regenerate the base file.
  67
  68 /*-------------------------------------------------------------------------*/
  69 /*                               Sync                                      */
  70
  71 void DoubleTransform::changed(ConstFieldMaskArg whichField,
  72                               UInt32            origin,
  73                               BitVector         details)
  74 {
  75     if(whichField & MatrixFieldMask)
  76     {
  77         invalidateVolume();
  78     }
  79
  80     Inherited::changed(whichField, origin, details);
  81 }
  82
  83 /***************************************************************************\
  84  *                           Class variables                               *
  85 \***************************************************************************/
  86
  87 /***************************************************************************\
  88  *                           Class methods                                 *
  89 \***************************************************************************/
  90
  91 /***************************************************************************\
  92  *                           Instance methods                              *
  93 \***************************************************************************/
  94
  95 /*----------------------------- class specific ----------------------------*/
  96
  97 void DoubleTransform::accumulateMatrix(Matrix &result)
  98 {
  99     result.mult(getMatrix());
 100 }
 101
 102 void DoubleTransform::adjustVolume(Volume &volume)
 103 {
 104     Matrix4f temp;
 105     temp.convertFrom(_sfMatrix.getValue());
 106     volume.transform(temp);
 107 }
 108
 109 void DoubleTransform::dump(      UInt32    uiIndent,
 110                            const BitVector bvFlags ) const
 111 {
 112     Inherited::dump(uiIndent, bvFlags);
 113 }
 114
 115 /*-------------------------------------------------------------------------*\
 116  -  private                                                                 -
 117 \*-------------------------------------------------------------------------*/
 118
 119 /*----------------------- constructors & destructors ----------------------*/
 120
 121 DoubleTransform::DoubleTransform(void) :
 122     Inherited()
 123 {
 124     _sfMatrix.getValue().setIdentity();
 125 }
 126
 127 DoubleTransform::DoubleTransform(const DoubleTransform &source) :
 128     Inherited(source)
 129 {
 130 }
 131
 132 DoubleTransform::~DoubleTransform(void)
 133 {
 134 }
 135
 136 /*-------------------------------------------------------------------------*/
 137 /*                                Render                                   */
 138
 139 Action::ResultE DoubleTransform::renderEnter(Action *action)
 140 {
 141     RenderAction *pAction = dynamic_cast<RenderAction *>(action);
 142
 143     pAction->pushVisibility();
 144
 145     pAction->pushMatrix(this->getMatrix());
 146
 147     return Action::Continue;
 148 }
 149
 150 Action::ResultE DoubleTransform::renderLeave(Action *action)
 151 {
 152     RenderAction *pAction = dynamic_cast<RenderAction *>(action);
 153
 154     pAction->popVisibility();
 155
 156     pAction->popMatrix();
 157
 158     return Action::Continue;
 159 }
 160
 161 /*-------------------------------------------------------------------------*/
 162 /*                            Intersect                                    */
 163
 164 Action::ResultE DoubleTransform::intersectEnter(Action *action)
 165 {
 166     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 167     Matrix4d         matd = this->getMatrix();
 168
 169     matd.invert();
 170
 171     Matrix4f m;
 172     m.convertFrom(matd);
 173
 174     Pnt3f pos;
 175     Vec3f dir;
 176
 177     m.multFull(ia->getLine().getPosition (), pos);
 178     m.mult    (ia->getLine().getDirection(), dir);
 179
 180     ia->setLine(Line(pos, dir), ia->getMaxDist());
 181     ia->scale(dir.length());
 182
 183     return Action::Continue;
 184 }
 185
 186 Action::ResultE DoubleTransform::intersectLeave(Action *action)
 187 {
 188     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 189     Matrix4d         matd = this->getMatrix();
 190
 191     Matrix4f m;
 192     m.convertFrom(matd);
 193
 194     Pnt3f pos;
 195     Vec3f dir;
 196
 197     m.multFull(ia->getLine().getPosition (), pos);
 198     m.mult    (ia->getLine().getDirection(), dir);
 199
 200     ia->setLine(Line(pos, dir), ia->getMaxDist());
 201     ia->scale(dir.length());
 202
 203     return Action::Continue;
 204 }
 205
 206 #ifdef OSG_HAVE_ACTION //CHECK
 207 NewActionTypes::ResultE Transform::intersectActorEnter(
 208     ActorBase::FunctorArgumentType &funcArg)
 209 {
 210     IntersectActor *pIA        = dynamic_cast<IntersectActor *>(
 211                                                            funcArg.getActor());
 212     Matrix          matrix     = this->getMatrix();
 213     Line            transLine;
 214     Pnt3f           pos;
 215     Vec3f           dir;
 216
 217     matrix.invert();
 218
 219     matrix.multFullMatrixPnt(pIA->getRay().getPosition (), pos);
 220     matrix.multMatrixVec    (pIA->getRay().getDirection(), dir);
 221
 222     transLine.setValue(pos, dir);
 223
 224     pIA->beginEditState();
 225     {
 226         pIA->setRay        (transLine                           );
 227         pIA->setScaleFactor(pIA->getScaleFactor() / dir.length());
 228     }
 229     pIA->endEditState  ();
 230
 231     pIA->setupChildrenPriorities();
 232
 233     return NewActionTypes::Continue;
 234 }
 235
 236 NewActionTypes::ResultE Transform::intersectActorLeave(
 237     ActorBase::FunctorArgumentType &funcArg)
 238 {
 239     IntersectActor *pIA    = dynamic_cast<IntersectActor *>(
 240                                                            funcArg.getActor());
 241     const Matrix   &matrix = this->getMatrix();
 242           Pnt3f     pos;
 243           Vec3f     dir;
 244
 245     matrix.multFullMatrixPnt(pIA->getRay().getPosition (), pos);
 246     matrix.multMatrixVec    (pIA->getRay().getDirection(), dir);
 247
 248     pIA->beginEditState();
 249     {
 250         pIA->setRay        (Line(pos, dir)                      );
 251         pIA->setScaleFactor(pIA->getScaleFactor() / dir.length());
 252     }
 253     pIA->endEditState  ();
 254
 255     return NewActionTypes::Continue;
 256 }
 257 #endif
 258
 259 /*-------------------------------------------------------------------------*/
 260 /*                                Init                                     */
 261
 262 void DoubleTransform::initMethod(InitPhase ePhase)
 263 {
 264     Inherited::initMethod(ePhase);
 265
 266     if(ePhase == TypeObject::SystemPost)
 267     {
 268         IntersectAction::registerEnterDefault(
 269             getClassType(),
 270             reinterpret_cast<Action::Callback>(&DoubleTransform::intersectEnter));
 271
 272         IntersectAction::registerLeaveDefault(
 273             getClassType(),
 274             reinterpret_cast<Action::Callback>(&DoubleTransform::intersectLeave));
 275
 276         RenderAction::registerEnterDefault(
 277             getClassType(),
 278             reinterpret_cast<Action::Callback>(&DoubleTransform::renderEnter));
 279
 280         RenderAction::registerLeaveDefault(
 281             getClassType(),
 282             reinterpret_cast<Action::Callback>(&DoubleTransform::renderLeave));
 283
 284 #ifdef OSG_HAVE_ACTION //CHECK
 285     IntersectActor::regClassEnter(
 286         osgTypedMethodFunctor2BaseCPtr<
 287           NewActionTypes::ResultE,
 288           TransformPtr           ,
 289           NodeCorePtr            ,
 290           ActorBase::FunctorArgumentType &>(&DoubleTransform::intersectActorEnter),
 291         getClassType());
 292
 293     IntersectActor::regClassLeave(
 294         osgTypedMethodFunctor2BaseCPtr<
 295           NewActionTypes::ResultE,
 296           TransformPtr           ,
 297           NodeCorePtr            ,
 298           ActorBase::FunctorArgumentType &>(&DoubleTransform::intersectActorLeave),
 299         getClassType());
 300 #endif
 301     }
 302 }
 303
 304
 305 OSG_END_NAMESPACE