Source/System/NodeCores/Groups/Misc/OSGStackedTransform.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 "OSGStackedTransform.h"
  49 #include "OSGTransformationElement.h"
  50 #include "OSGIntersectAction.h"
  51
  52 #include "OSGRenderAction.h"
  53 #include "OSGNameAttachment.h"
  54
  55 #include "OSGVolume.h"
  56
  57 OSG_BEGIN_NAMESPACE
  58
  59 // Documentation for this class is emitted in the
  60 // OSGStackedTransformBase.cpp file.
  61 // To modify it, please change the .fcd file (OSGStackedTransform.fcd) and
  62 // regenerate the base file.
  63
  64 /***************************************************************************\
  65  *                           Class variables                               *
  66 \***************************************************************************/
  67
  68 std::string StackedTransform::TranslateName = std::string("translate");
  69 std::string StackedTransform::RotateXName   = std::string("rotateX"  );
  70 std::string StackedTransform::RotateYName   = std::string("rotateY"  );
  71 std::string StackedTransform::RotateZName   = std::string("rotateZ"  );
  72 std::string StackedTransform::ScaleName     = std::string("scale"    );
  73
  74 /***************************************************************************\
  75  *                           Class methods                                 *
  76 \***************************************************************************/
  77
  78 void StackedTransform::initMethod(InitPhase ePhase)
  79 {
  80     Inherited::initMethod(ePhase);
  81
  82     if(ePhase == TypeObject::SystemPost)
  83     {
  84         RenderAction::registerEnterDefault(
  85             StackedTransform::getClassType(),
  86             reinterpret_cast<Action::Callback>(
  87                 &StackedTransform::renderEnter));
  88
  89         RenderAction::registerLeaveDefault(
  90             StackedTransform::getClassType(),
  91             reinterpret_cast<Action::Callback>(
  92                 &StackedTransform::renderLeave));
  93
  94
  95         IntersectAction::registerEnterDefault(
  96             getClassType(),
  97             reinterpret_cast<Action::Callback>(
  98                 &StackedTransform::intersectEnter));
  99
 100         IntersectAction::registerLeaveDefault(
 101             getClassType(),
 102             reinterpret_cast<Action::Callback>(
 103                 &StackedTransform::intersectLeave));
 104     }
 105 }
 106
 107
 108 /***************************************************************************\
 109  *                           Instance methods                              *
 110 \***************************************************************************/
 111
 112 void StackedTransform::updateTransform(void)
 113 {
 114     _mTransformation.setIdentity();
 115
 116     for(UInt32 i =0; i < getMFTransformElements()->size(); ++i)
 117     {
 118         getTransformElements(i)->accumulateMatrix(_mTransformation);
 119     }
 120
 121     invalidateVolume();
 122 }
 123
 124 void StackedTransform::accumulateMatrix(Matrix &result)
 125 {
 126     result.mult(_mTransformation);
 127 }
 128
 129 void StackedTransform::adjustVolume(Volume &volume)
 130 {
 131     volume.transform(_mTransformation);
 132 }
 133
 134 TransformationElement *StackedTransform::getElement(
 135     const std::string &szName) const
 136 {
 137     const Char8 *szElemName = NULL;
 138
 139     for(UInt32 i = 0; i < getMFTransformElements()->size(); ++i)
 140     {
 141         szElemName = getName(getTransformElements(i));
 142
 143         if(szElemName != NULL && szName.compare(szElemName) == 0)
 144         {
 145             return getTransformElements(i);
 146         }
 147     }
 148
 149     return NULL;
 150 }
 151
 152 void StackedTransform::pushToNamedTransformElements(
 153     TransformationElement       * const pValue,
 154     std::string           const &       szName)
 155 {
 156     setName(pValue, szName.c_str());
 157
 158     Inherited::pushToTransformElements(pValue);
 159 }
 160
 161 void StackedTransform::insertIntoNamedTransformElements(
 162     UInt32                              uiIndex,
 163     TransformationElement       * const pValue,
 164     std::string           const &       szName)
 165 {
 166     setName(pValue, szName.c_str());
 167
 168     Inherited::insertIntoTransformElements(uiIndex, pValue);
 169 }
 170
 171 void StackedTransform::replaceInNamedTransformElements(
 172     UInt32                              uiIndex,
 173     TransformationElement       * const pValue,
 174     std::string           const &       szName)
 175 {
 176     setName(pValue, szName.c_str());
 177
 178     Inherited::replaceInTransformElements(uiIndex, pValue);
 179 }
 180
 181 void StackedTransform::replaceObjInNamedTransformElements(
 182     TransformationElement       * const pOldElem,
 183     TransformationElement       * const pNewElem,
 184     std::string           const &       szName  )
 185 {
 186     setName(pNewElem, szName.c_str());
 187
 188     Inherited::replaceObjInTransformElements(pOldElem, pNewElem);
 189 }
 190
 191 void StackedTransform::removeFromNamedTransformElements(
 192     const std::string &szName)
 193 {
 194     const Char8 *szElemName = NULL;
 195
 196     for(UInt32 i = 0; i < getMFTransformElements()->size(); ++i)
 197     {
 198         szElemName = getName(getTransformElements(i));
 199
 200         if(szElemName != NULL && szName.compare(szElemName) == 0)
 201         {
 202             Inherited::removeFromTransformElements(i);
 203
 204             return;
 205         }
 206     }
 207 }
 208
 209 /*-------------------------------------------------------------------------*/
 210 /*                                Render                                   */
 211
 212 Action::ResultE StackedTransform::renderEnter(Action *action)
 213 {
 214     RenderAction *pAction = dynamic_cast<RenderAction *>(action);
 215
 216     pAction->pushVisibility();
 217
 218     pAction->pushMatrix(this->_mTransformation);
 219
 220     return Action::Continue;
 221 }
 222
 223 Action::ResultE StackedTransform::renderLeave(Action *action)
 224 {
 225     RenderAction *pAction = dynamic_cast<RenderAction *>(action);
 226
 227     pAction->popVisibility();
 228
 229     pAction->popMatrix();
 230
 231     return Action::Continue;
 232 }
 233
 234 /*-------------------------------------------------------------------------*/
 235 /*                            Intersect                                    */
 236
 237 Action::ResultE StackedTransform::intersectEnter(Action *action)
 238 {
 239     // Use parent class for trivial reject
 240     if(Inherited::intersectEnter(action) == Action::Skip)
 241         return Action::Skip;
 242
 243     // Need to check children
 244     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 245     Matrix           m  = this->_mTransformation;
 246
 247     m.invert();
 248
 249     Pnt3f pos;
 250     Vec3f dir;
 251
 252     m.multFull(ia->getLine().getPosition (), pos);
 253     m.mult    (ia->getLine().getDirection(), dir);
 254
 255     Real32 length = dir.length();
 256
 257     if(length < TypeTraits<Real32>::getDefaultEps())
 258         SWARNING << "StackedTransform::intersectEnter: Near-zero scale!"
 259                  << std::endl;
 260
 261     ia->setLine(Line(pos, dir), ia->getMaxDist());
 262     ia->scale  (length                          );
 263
 264     return Action::Continue;
 265 }
 266
 267 Action::ResultE StackedTransform::intersectLeave(Action *action)
 268 {
 269     IntersectAction *ia = dynamic_cast<IntersectAction *>(action);
 270     Matrix           m  = this->_mTransformation;
 271
 272     Pnt3f pos;
 273     Vec3f dir;
 274
 275     m.multFull(ia->getLine().getPosition (), pos);
 276     m.mult    (ia->getLine().getDirection(), dir);
 277
 278     ia->setLine(Line(pos, dir), ia->getMaxDist());
 279     ia->scale(dir.length());
 280
 281     return Action::Continue;
 282 }
 283
 284 /*-------------------------------------------------------------------------*\
 285  -  private                                                                 -
 286 \*-------------------------------------------------------------------------*/
 287
 288 /*----------------------- constructors & destructors ----------------------*/
 289
 290 StackedTransform::StackedTransform(void) :
 291      Inherited      (),
 292     _mTransformation()
 293 {
 294     _mTransformation.setIdentity();
 295 }
 296
 297 StackedTransform::StackedTransform(const StackedTransform &source) :
 298      Inherited      (source                 ),
 299     _mTransformation(source._mTransformation)
 300 {
 301 }
 302
 303 StackedTransform::~StackedTransform(void)
 304 {
 305 }
 306
 307 /*----------------------------- class specific ----------------------------*/
 308
 309 void StackedTransform::changed(ConstFieldMaskArg whichField,
 310                             UInt32            origin,
 311                             BitVector         details)
 312 {
 313     Inherited::changed(whichField, origin, details);
 314
 315     if((whichField & TransformElementsFieldMask))
 316     {
 317         updateTransform();
 318     }
 319 }
 320
 321 void StackedTransform::dump(      UInt32    ,
 322                             const BitVector ) const
 323 {
 324     SLOG << "Dump StackedTransform NI" << std::endl;
 325 }
 326
 327 OSG_END_NAMESPACE