Source/System/Action/IntersectAction/OSGIntersectAction.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 <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGLog.h"
  49 #include "OSGFieldContainer.h"
  50 #include "OSGNode.h"
  51 #include "OSGNodeCore.h"
  52 #include "OSGAction.h"
  53 #include "OSGIntersectAction.h"
  54 #include "OSGIntersectProxyAttachment.h"
  55
  56 #include <boost/bind.hpp>
  57
  58 OSG_USING_NAMESPACE
  59
  60
  61 /***************************************************************************\
  62  *                            Description                                  *
  63 \***************************************************************************/
  64
  65 /*! \class OSG::IntersectAction
  66     \ingroup GrpSystemAction
  67
  68   The intersect action class.
  69
  70 */
  71
  72 /***************************************************************************\
  73  *                               Types                                     *
  74 \***************************************************************************/
  75
  76 /***************************************************************************\
  77  *                           Class variables                               *
  78 \***************************************************************************/
  79
  80 StatElemDesc<StatTimeElem>  IntersectAction::statTravTime(
  81     "IA-Time",
  82     "time needed for intersect");
  83
  84 StatElemDesc<StatIntElem >  IntersectAction::statNNodes(
  85     "IA-NNodes",
  86     "number of nodes visited");
  87
  88 StatElemDesc<StatIntElem >  IntersectAction::statNTriangles(
  89     "IA-NTrianles",
  90     "number of triangles tested");
  91
  92 IntersectAction      *IntersectAction::_prototype            = NULL;
  93
  94 Action::FunctorStore *IntersectAction::_defaultEnterFunctors = NULL;
  95 Action::FunctorStore *IntersectAction::_defaultLeaveFunctors = NULL;
  96
  97 /***************************************************************************\
  98  *                           Class methods                                 *
  99 \***************************************************************************/
 100
 101 bool IntersectAction::terminateEnter(void)
 102 {
 103     FDEBUG_GV(("Terminate IntersectAction Enter\n"));
 104
 105     delete _defaultEnterFunctors;
 106
 107     _defaultEnterFunctors = NULL;
 108
 109     return true;
 110 }
 111
 112 bool IntersectAction::terminateLeave(void)
 113 {
 114     FDEBUG_GV(("Terminate IntersectAction Leave\n"));
 115
 116     delete _defaultLeaveFunctors;
 117
 118     _defaultLeaveFunctors = NULL;
 119
 120     return true;
 121 }
 122
 123 /*-------------------------------------------------------------------------*\
 124  -  public                                                                 -
 125 \*-------------------------------------------------------------------------*/
 126
 127 void IntersectAction::registerEnterDefault(const FieldContainerType &type,
 128                                            const Action::Functor    &func)
 129 {
 130     if(! _defaultEnterFunctors)
 131     {
 132         _defaultEnterFunctors = new FunctorStore;
 133
 134         addPostFactoryExitFunction(&IntersectAction::terminateEnter);
 135     }
 136
 137     while(type.getId() >= _defaultEnterFunctors->size())
 138     {
 139         _defaultEnterFunctors->push_back(
 140             &IntersectAction::_defaultEnterFunction);
 141     }
 142
 143     (*_defaultEnterFunctors)[type.getId()] = func;
 144 }
 145
 146 void IntersectAction::registerLeaveDefault(const FieldContainerType &type,
 147                                            const Action::Functor    &func)
 148 {
 149     if(! _defaultLeaveFunctors)
 150     {
 151         _defaultLeaveFunctors = new FunctorStore;
 152
 153         addPostFactoryExitFunction(&IntersectAction::terminateLeave);
 154     }
 155
 156     while(type.getId() >= _defaultLeaveFunctors->size())
 157     {
 158         _defaultLeaveFunctors->push_back(
 159             &IntersectAction::_defaultLeaveFunction);
 160     }
 161
 162     (*_defaultLeaveFunctors)[type.getId()] = func;
 163 }
 164
 165 void IntersectAction::setPrototype(IntersectAction *proto)
 166 {
 167     _prototype = proto;
 168 }
 169
 170 IntersectAction *IntersectAction::getPrototype(void)
 171 {
 172     return _prototype;
 173 }
 174
 175 StatCollector *IntersectAction::getStatCollector(void) const
 176 {
 177     return _statistics;
 178 }
 179
 180 void IntersectAction::setStatCollector(StatCollector *sc)
 181 {
 182     _statistics = sc;
 183 }
 184
 185 bool IntersectAction::getResetStatistics(void) const
 186 {
 187     return _resetStatistics;
 188 }
 189
 190 void IntersectAction::setResetStatistics(bool value)
 191 {
 192     _resetStatistics = value;
 193 }
 194
 195 /*-------------------------------------------------------------------------*\
 196  -  protected                                                              -
 197 \*-------------------------------------------------------------------------*/
 198
 199
 200 /*-------------------------------------------------------------------------*\
 201  -  private                                                                -
 202 \*-------------------------------------------------------------------------*/
 203
 204
 205
 206 /***************************************************************************\
 207  *                           Instance methods                              *
 208 \***************************************************************************/
 209
 210 /*-------------------------------------------------------------------------*\
 211  -  public                                                                 -
 212 \*-------------------------------------------------------------------------*/
 213
 214 /*------------- constructors & destructors --------------------------------*/
 215
 216 /** \brief Constructor
 217  */
 218
 219 IntersectAction::IntersectAction(void) :
 220      Inherited      (     ),
 221     _line           (     ),
 222     _testLines      (false),
 223     _lineTestWidth  (  0.0),
 224     _maxdist        (     ),
 225     _hit            (false),
 226     _enterT         (   -1),
 227     _leaveT         (   -1),
 228     _path           (     ),
 229     _hitT           (   -1),
 230     _hitObject      (     ),
 231     _hitPath        (     ),
 232     _hitTriangle    (   -1),
 233     _hitNormal      (     ),
 234     _hitLine        (   -1),
 235     _statistics     (NULL ),
 236     _resetStatistics(true )
 237 {
 238     if(_defaultEnterFunctors)
 239         _enterFunctors = *_defaultEnterFunctors;
 240
 241     if(_defaultLeaveFunctors)
 242         _leaveFunctors = *_defaultLeaveFunctors;
 243
 244     _nodeEnterCB = boost::bind(&IntersectAction::onEnterNode, this, _1, _2);
 245     _nodeLeaveCB = boost::bind(&IntersectAction::onLeaveNode, this, _1, _2);
 246 }
 247
 248
 249 IntersectAction::IntersectAction(const IntersectAction& source) :
 250      Inherited      (source                 ),
 251     _line           (source._line           ),
 252     _testLines      (source._testLines      ),
 253     _lineTestWidth  (source._lineTestWidth  ),
 254     _maxdist        (source._maxdist        ),
 255     _hit            (source._hit            ),
 256     _enterT         (source._enterT         ),
 257     _leaveT         (source._leaveT         ),
 258     _path           (source._path           ),
 259     _hitT           (source._hitT           ),
 260     _hitObject      (source._hitObject      ),
 261     _hitPath        (source._hitPath        ),
 262     _hitTriangle    (source._hitTriangle    ),
 263     _hitNormal      (source._hitNormal      ),
 264     _hitLine        (source._hitLine        ),
 265     _statistics     (source._statistics     ),
 266     _resetStatistics(source._resetStatistics)
 267 {
 268     _nodeEnterCB = boost::bind(&IntersectAction::onEnterNode, this, _1, _2);
 269     _nodeLeaveCB = boost::bind(&IntersectAction::onLeaveNode, this, _1, _2);
 270 }
 271
 272
 273 /** \brief create a new action
 274  */
 275
 276 IntersectAction::ObjTransitPtr IntersectAction::create(void)
 277 {
 278     ObjTransitPtr act(NULL);
 279
 280     if(_prototype)
 281     {
 282         act = new IntersectAction(*_prototype);
 283     }
 284     else
 285     {
 286         act = new IntersectAction();
 287     }
 288
 289     return act;
 290 }
 291
 292
 293 /** \brief create a new action
 294  */
 295
 296 IntersectAction::ObjTransitPtr IntersectAction::create(const Line   &line,
 297                                                        const Real32  maxdist)
 298 {
 299     ObjTransitPtr act(NULL);
 300
 301     if(_prototype)
 302     {
 303         act = new IntersectAction(*_prototype);
 304     }
 305     else
 306     {
 307         act = new IntersectAction();
 308     }
 309
 310     act->setLine(line, maxdist);
 311
 312     return act;
 313 }
 314
 315 /** \brief Destructor
 316  */
 317
 318 IntersectAction::~IntersectAction(void)
 319 {
 320 }
 321
 322 /*---------------------------- application --------------------------------*/
 323
 324 /*---------------------------- properties ---------------------------------*/
 325
 326 void IntersectAction::setLine(const Line &line, const Real32 maxdist)
 327 {
 328     _line    = line;
 329     _maxdist = maxdist;
 330 }
 331
 332 void IntersectAction::setTestLines( bool value )
 333 {
 334     _testLines = value;
 335 }
 336
 337 void IntersectAction::setTestLineWidth(Real32 width)
 338 {
 339     _lineTestWidth = width;
 340 }
 341
 342 Action::ResultE IntersectAction::setEnterLeave(Real32 enter, Real32 leave)
 343 {
 344     if(leave < 0 || enter > _maxdist ||
 345        ( _hit && enter > _hitT ))
 346     {
 347         return Action::Skip;
 348     }
 349
 350     return Action::Continue;
 351 }
 352
 353 /** Attempt to set the new hit for the intersection.
 354  *  The hit is only set if this hit would be closer then the existing hit position.
 355  *  @param t  The distance along the ray that the hit occurred.
 356  *  @param obj The Node object that was hit.
 357  *  @param triIndex The index of the triangle in the geometry hit.
 358  *  @param normal   The normal at the hit location.
 359  *  @param lineIndex The index of the line in the geometry hit.
 360  */
 361 void IntersectAction::setHit(      Real32  t,
 362                                    Node   *obj,
 363                                    Int32   triIndex,
 364                              const Vec3f  &normal,
 365                                    Int32   lineIndex)
 366 {
 367     if(t < 0 || t > _hitT || t > _maxdist)
 368         return;
 369
 370     _hitT        = t;
 371     _hitObject   = obj;
 372     _hitPath     = _path;
 373     _hitTriangle = triIndex;
 374     _hitNormal   = normal;
 375     _hitLine     = lineIndex;
 376     _hit         = true;
 377 }
 378
 379 void IntersectAction::scale(Real32 s)
 380 {
 381     _hitT    *= s;
 382     _maxdist *= s;
 383 }
 384
 385 /*-------------------------- your_category---------------------------------*/
 386
 387
 388 Action::ResultE IntersectAction::start(void)
 389 {
 390     _hitT        = Inf;
 391     _hitObject   = NULL;
 392     _hitTriangle = -1;
 393     _hitLine     = -1;
 394     _hit         = false;
 395     _hitPath.clear();
 396     _path.clear();
 397
 398     // reserve some memory for a scene depth of 20
 399     // TODO: is this a sensible number?
 400     _hitPath.reserve(20);
 401     _path.reserve(20);
 402
 403     if(_statistics == NULL)
 404         _statistics = new StatCollector;
 405
 406     if(_resetStatistics == true)
 407         _statistics->reset();
 408
 409     _statistics->getElem(statTravTime)->start();
 410
 411     return Continue;
 412 }
 413
 414 Action::ResultE IntersectAction::stop(ResultE res)
 415 {
 416     _statistics->getElem(statTravTime)->stop();
 417
 418     return res;
 419 }
 420
 421
 422 /*-------------------------- assignment -----------------------------------*/
 423
 424 /*-------------------------- comparison -----------------------------------*/
 425
 426 /** \brief assignment
 427  */
 428
 429 bool IntersectAction::operator < (const IntersectAction &other) const
 430 {
 431     return this < &other;
 432 }
 433
 434 /** \brief equal
 435  */
 436
 437 bool IntersectAction::operator == (
 438     const IntersectAction &OSG_CHECK_ARG(other)) const
 439 {
 440     return false;
 441 }
 442
 443 /** \brief unequal
 444  */
 445
 446 bool IntersectAction::operator != (const IntersectAction &other) const
 447 {
 448     return ! (*this == other);
 449 }
 450
 451
 452 /*-------------------------------------------------------------------------*\
 453  -  protected                                                              -
 454 \*-------------------------------------------------------------------------*/
 455
 456
 457 Action::FunctorStore *IntersectAction::getDefaultEnterFunctors(void)
 458 {
 459     return _defaultEnterFunctors;
 460 }
 461
 462 Action::FunctorStore *IntersectAction::getDefaultLeaveFunctors(void)
 463 {
 464     return _defaultLeaveFunctors;
 465 }
 466
 467 /*-------------------------------------------------------------------------*\
 468  -  private                                                                -
 469 \*-------------------------------------------------------------------------*/
 470
 471 Action::ResultE IntersectAction::onEnterNode(Node* node, Action* action)
 472 {
 473     OSG_ASSERT(this == action && node == _actNode);
 474
 475     ResultE result = Continue;
 476
 477     _path.push_back(node);
 478
 479     _statistics->getElem(statNNodes)->inc();
 480
 481     IntersectProxyAttachment* ipa = dynamic_cast<IntersectProxyAttachment*>(
 482         node->findAttachment(IntersectProxyAttachment::getClassType()));
 483
 484     if(ipa != NULL)
 485     {
 486         result = ipa->intersectEnter(node, this);
 487     }
 488
 489     return result;
 490 }
 491
 492 Action::ResultE IntersectAction::onLeaveNode(Node* node, Action* action)
 493 {
 494     OSG_ASSERT(this == action && node == _actNode);
 495
 496     ResultE result = Continue;
 497
 498     _path.pop_back();
 499
 500     return result;
 501 }