RayIntExplorer.cc

Go to the documentation of this file.

#include <esg/explorer/RayIntExplorer.h>
#include <esg/iterator/IteratorSDS.h>
#include <esg/Statistics.h>

using namespace esg;

#ifdef ESG_STATISTICS
#define RIE_INC_TEST     { _primTestsCounter++; }
#define RIE_INC_SUC_TEST { _primTestsSucCounter++; }
#define RIE_UPDATE_STAT  { \
    ((Counter*)Statistics::instance()->get(Statistics::OID_PRIM_TESTS)->receptor())->add(_primTestsCounter); \
    ((Counter*)Statistics::instance()->get(Statistics::OID_PRIM_TESTS_SUC)->receptor())->add(_primTestsSucCounter); \
    _primTestsCounter = (_primTestsSucCounter = 0); \
}
#else
#define RIE_INC_TEST     {}
#define RIE_INC_SUC_TEST {}
#define RIE_UPDATE_STAT  {}
#endif // ESG_STATISTICS


bool RayIntExplorer::_explore(SceneGraphObject& obj)
{
    Transform* pTr = obj.transformation();

    if (pTr) { // new transformation => update stack
        Matrix4* auxMat = new Matrix4(pTr->get());
        if (!_trStack.empty()) auxMat->mul(*_trStack.top(), *auxMat);
        _trStack.push(auxMat);
        _rMat.set(*(pTr->getRotation()));
        _tVec = pTr->getTranslation();
        _sVec = pTr->getScale();
        ESG_INVERSE_TR_RAY(_rMat, *_tVec, *_sVec,
                           _origin, _trOrigin, _direction, _trDirection);
    }

    /*
     * Inspect subnodes and/or attributes
     */
    if (obj.hasSubnodes()) { // iterate
        _retVal = false;
        IteratorSDS* pIter = obj.traverseSubnodes();
        if (pIter) {
            pIter->initRayIntersection(_trOrigin,_trDirection,true,_maxDist);
            _pCandidate = pIter->firstChild();
            while (_pCandidate) {
                _retVal  = _explore(*_pCandidate);
                _actDist = _pIntersector->getActDistance();
                if (_actDist < _maxDist) {
                    _maxDist = _actDist;
                    pIter->initRayIntersection(_trOrigin, _trDirection,
                                               false, _maxDist);
                }
                _pCandidate = pIter->nextChild();
            }
            delete pIter;
        }
    } else { // process_leaf
        RIE_INC_TEST;
        if (_pIntersector->processCandidate(&obj, _trOrigin, _trDirection)) {
            if (_trStack.empty())
                _transformed = false;
            else {
                _accumMat.set(*_trStack.top());
                _transformed = true;
            }
            _retVal = true;
            RIE_INC_SUC_TEST;
        } else
            _retVal = false;
    }

    /*
     * Erase my transform. matrix after backtracking children
     */
    if (pTr) {
        delete _trStack.top();
        _trStack.pop();
    }

    return _retVal;
}

RayIntExplorer::RayIntExplorer(const Vector3& o,
                               const Vector3& d,
                               Intersector*   pI,
                               float          m)
    : _origin(o),
      _direction(d),
      _pIntersector(pI),
      _maxDist(m),
      _trOrigin(o),
      _trDirection(d),
      _transformed(false)
{
#ifdef ESG_STATISTICS
    _primTestsCounter = 0;
    _primTestsSucCounter = 0;
#endif // ESG_STATISTICS
}

void RayIntExplorer::explore(SceneGraphObject& obj)
{
    if (!_pIntersector) return;
    (void) _explore(obj);
}


void RayIntExplorer::reinit(const Vector3& o,
                            const Vector3& d,
                            Intersector*   pI,
                            float          m)
{
    RIE_UPDATE_STAT;
    _transformed = false;
    _origin.set(o);
    _direction.set(d);
    _trOrigin.set(o);
    _trDirection.set(d);
    _pIntersector = pI;
    _maxDist = m;
}

PointEnv* RayIntExplorer::result()
{
    PointEnv* p = NULL;
    if (_pIntersector) p = _pIntersector->adoptIntersection();
    if (p && _transformed) {
        p->trMat.set(_accumMat);
        p->mask |= ENV_HAVE_TRANSFORMATION;
    }
    RIE_UPDATE_STAT;
    return p;
}

#ifdef ESG_STATISTICS
#undef RIE_INC_TEST    
#undef RIE_INC_SUC_TEST
#undef RIE_UPDATE_STAT
#endif // ESG_STATISTICS

---