C++ IntersectAction::setHit方法代码示例

/*! The IntersectAction callback for Geometry. It computes if the ray used in
    the IntersectAction \a action hits this object and if that is the case,
    which triangle is hit.

    \param[in] action IntersectAction performing the intersect test.
    \return Action result code, \see OSG::Action.

    \note This method is registered with the IntersectAction and automatically
    called from there, you probably never have to call it manually.
*/
Action::ResultE Geometry::intersect(Action * action)
{
    IntersectAction      *ia = dynamic_cast<IntersectAction*>(action);
   
    ia->getActNode()->updateVolume();
    const BoxVolume      &bv = ia->getActNode()->getVolume();

    if(bv.isValid() && !bv.intersect(ia->getLine()))
    {
        return Action::Skip; //bv missed -> can not hit children
    }

    TriangleIterator it  = this->beginTriangles();
    TriangleIterator end = this->endTriangles  ();
    Real32           t;
    Vec3f            norm;
    Line             ia_line(ia->getLine());

    for(; it != end; ++it)
    {
        if(ia_line.intersect(it.getPosition(0),
                             it.getPosition(1),
                             it.getPosition(2), t, &norm))
        {
            ia->setHit(t, ia->getActNode(), it.getIndex(), norm, -1);
        }
    }

    // If we need to test lines, iterate over lines and test for
    // lines that are within width distance from the line
    if(ia->getTestLines())
    {       
       Real32 range_sq  = ia->getTestLineWidth();
       range_sq         = range_sq * range_sq;
       LineIterator it  = this->beginLines();
       LineIterator end = this->endLines  ();
       Pnt3f  pt1, pt2;
       OSG::Vec3f  norm;       

       // Find closest points and if they are within the range, then add a hit
       for(; it != end; ++it)
       {          
          Line cur_line(it.getPosition(0), it.getPosition(1));
          ia_line.getClosestPoints(cur_line, pt1, pt2);
          Real32 dist_sq( pt1.dist2(pt2) );

          if (dist_sq <= range_sq)
          {
             t = ia_line.getPosition().dist(pt1);
             ia->setHit(t, ia->getActNode(), -1, norm, it.getIndex());
          }
       }
    }

    return Action::Continue;
}

//! intersection test
Action::ResultE DVRVolume::intersect(Action * action)
{ 
    FDEBUG(("DVRVolume::intersect\n"));

          IntersectAction *ia  = dynamic_cast<IntersectAction*>(action);
#ifndef OSG_2_PREP
    const DynamicVolume   &vol = ia->getActNode()->getVolume();
#else
    const BoxVolume       &vol = ia->getActNode()->getVolume();
#endif
    
    if(vol.isValid() && !vol.intersect(ia->getLine()))
    {
        return Action::Skip; //bv missed -> can not hit children
    }

    //!! FIXME: simulate hit when bounding volume is hit

    Real32 t, v;
    Vec3f  norm;

    if(vol.intersect(ia->getLine(), t, v))
        ia->setHit(t, ia->getActNode(), 0, norm);
    
    return Action::Continue;
}

	Action::ResultE DynamicTerrain::intersectEnter(Action* action )
	{
		IntersectAction       *ia = dynamic_cast< IntersectAction* >( action );
	#ifndef OSG_2_PREP
		const DynamicVolume  &vol = ia->getActNode()->editVolume(true);
	#else
		const BoxVolume      &vol = ia->getActNode()->editVolume(true);
	#endif
		Real32 enter = 0, exit = 0;
	
		if(vol.isValid() && !vol.intersect(ia->getLine(), enter, exit))
		{
			return Action::Skip; //bv missed -> can not hit children
		}

		Real32 t = enter;
		Vec3f normal(0,0,0);
		Int32 index = -1;

		//if( geoClipmaps_.findFirstIntersection( ia->getLine(), t, normal ) )
		{
			ia->setHit( t, ia->getActNode(), index, normal );
		}

		return Action::Continue;
	}

/* virtual */ Action::ResultE
KDTreeIntersectProxyAttachment::intersectEnter(Node *node, Action *action)
{
    Action::ResultE  res  = Inherited::intersectEnter(node, action);
    IntersectAction *iact =
        boost::polymorphic_downcast<IntersectAction *>(action);

    Real32 closestHitT = iact->didHit() ? iact->getHitT() : iact->getMaxDist();
    Vec3f  hitNormal;
    UInt32 hitTriangle;

    if(_mfTreeNodes.empty() == false)
    {
        UInt32 numTris = 0;
        bool hit = intersectIntersectKDTree(iact->getLine(),
                                            node->getVolume(),
                                            _sfGeometry.getValue(),
                                            &_mfTreeNodes,
                                            &_mfTriIndices,
                                            closestHitT,
                                            hitNormal,
                                            hitTriangle,
                                            &numTris    );

        if(hit == true)
        {
            iact->setHit(closestHitT,
                         node,
                         hitTriangle,
                         hitNormal, 0);
        }

        iact->getStatCollector()->getElem(
            IntersectAction::statNTriangles)->add(numTris);
    }
    else
    {
        // tree was empty - skip this proxy and use conventional
        // intersect
        res = Action::Continue;
    }

    return res;
}

Action::ResultE geometryEnter(CNodePtr& node, Action * action) 
{ 
    IntersectAction * ia = dynamic_cast<IntersectAction*>(action);
    NodePtr n( node );
    Geometry* core =  dynamic_cast<Geometry*>(get_pointer(n->getCore()));

    TriangleIterator it;
    Real32 t;
    Vec3f norm;
    
    for ( it = core->beginTriangles(); it != core->endTriangles(); ++it )
    {
        if ( ia->getLine().intersect(   it.getPosition(0), 
                                        it.getPosition(1),
                                        it.getPosition(2), t, &norm ) )
        {
           ia->setHit( t, NodePtr(node), it.getIndex(), norm );
        }
    }
    
    return Action::Continue; 
}