bool SubdivPatch1Intersector1::subdivide_occluded1(const Precalculations& pre,
                                                    Ray& ray,
                                                    const BSplinePatch &patch,
                                                    const unsigned int geomID,
                                                    const unsigned int primID,
                                                    const unsigned int subdiv_level)
 {
   if (subdiv_level == 0)
   {
     __aligned(64) FinalQuad finalQuad;
     patch.init( finalQuad );
     
     if (occludedTri(finalQuad.vtx[0],
                     finalQuad.vtx[1],
                     finalQuad.vtx[2],
                     ray,
                     geomID,
                     primID,NULL)) return true; 
     
     if (occludedTri(finalQuad.vtx[2],
                     finalQuad.vtx[3],
                     finalQuad.vtx[0],
                     ray,
                     geomID,
                     primID,NULL)) return false;
   }
   else
   {
     BSplinePatch subpatches[4];
     patch.subdivide(subpatches);
     for (size_t i=0;i<4;i++)
       if (intersectBounds(pre,ray,subpatches[i].bounds()))
         if (subdivide_occluded1(pre,
                                 ray,
                                 subpatches[i],
                                 geomID,
                                 primID,
                                 subdiv_level - 1)) return true;
   }   
   return false;
 }
 void SubdivPatch1Intersector1::subdivide_intersect1(const Precalculations& pre,
                                                     Ray& ray,
                                                     const CatmullClarkPatch &patch,
                                                     const unsigned int geomID,
                                                     const unsigned int primID,
                                                     const unsigned int subdiv_level)
 {
   if (subdiv_level == 0)
   {
     __aligned(64) FinalQuad finalQuad;
     patch.init( finalQuad );
     
     intersectTri(finalQuad.vtx[0],
                  finalQuad.vtx[1],
                  finalQuad.vtx[2],
                  ray,
                  geomID,
                  primID,NULL); 
     
     intersectTri(finalQuad.vtx[2],
                  finalQuad.vtx[3],
                  finalQuad.vtx[0],
                  ray,
                  geomID,
                  primID,NULL); 
   }
   else
   {
     CatmullClarkPatch subpatches[4];
     patch.subdivide(subpatches);
     for (size_t i=0;i<4;i++)
       if (intersectBounds(pre,ray,subpatches[i].bounds()))
         subdivide_intersect1(pre,
                              ray,
                              subpatches[i],
                              geomID,
                              primID,
                              subdiv_level - 1);	    
   }   
 }
Esempio n. 3
0
// Funnel algorithm
void NavMap::funnel(Vector &start, Vector &end) {
	unTriangulatePath();

	funnelVector.swap(std::vector<Vector>());
	funnelVector.push_back(start);
	if(!intersectBounds(start, end)) {
		funnelVector.push_back(end);
		return;
	}
	
	portals.emplace(portals.begin(), start);
	portals.emplace(portals.begin(), start);
	portals.push_back(end);
	portals.push_back(end);

	Vector apex(start);
	Vector left(start);
	Vector right(start);

	int apexI = 0;
	int leftI = 0;
	int rightI = 0;

	Vector R;
	Vector L;

	for(unsigned int i = 2, j = 0; i < portals.size() && j < 1000; i+=2, j+=2){
		if(!intersectBounds(apex, end)) {
			funnelVector.push_back(end);
			return;
		}

		Vector &pi1 = portals[i + 1];
		Vector &pi = portals[i];

		R = pi1 + (pi - pi1) * 0.99;
		L = pi + (pi1 - pi) * 0.99;

		if(triarea2(apex, right, R) <= 0.f) {
			if(Vector::equal(apex, right, 0.01f) || triarea2(apex, left, R) >= 0.f) {
				right = R;
				rightI = i;
			} else {
				funnelVector.push_back(left);
				apex = left;
				apexI = leftI;

				right = apex;
				rightI = apexI;

				i = apexI;
				break;
			}
		}

		if(triarea2(apex, left, L) >= 0.f) {
			if(Vector::equal(apex, left, 0.01f) || triarea2(apex, right, L) <= 0.f) {
				left = L;
				leftI = i;
			} else {
				funnelVector.push_back(right);
				apex = right;
				apexI = rightI;

				left = apex;
				leftI = apexI;

				i = apexI;
				break;
			}
		}
	}
}
Esempio n. 4
0
bool Entity::intersect(const Ray& R, float& maxDistance, Model::HitInfo& info) const {
    return intersectBounds(R, maxDistance, info);
}