Ejemplo n.º 1
0
	std::vector<Point2d> Intersect(const Arc &arc, const Circle &circle) {
		return Intersect(circle, arc);
	}
Ejemplo n.º 2
0
	std::vector<vsr::cga2D::Vec> Intersect(const LineSegment &segment, const Circle &circle) {
		return Intersect(circle, segment);
	}
Ejemplo n.º 3
0
	std::vector<vsr::cga2D::Vec> Intersect(const Arc &arc, const LineSegment &segment) {
		return Intersect(segment, arc);
	}
Ejemplo n.º 4
0
int Hull::AddContactsHullHull(btSeparation& sep, const Point3* pVertsA, const Point3* pVertsB,
									   const Transform& trA, const Transform& trB,const Hull& hullA,const Hull& hullB,
									   HullContactCollector* hullContactCollector)
{
	const int maxContacts = hullContactCollector->GetMaxNumContacts();

	Vector3 normalWorld = sep.m_axis;

	// edge->edge contact is always a single point
	if (sep.m_separator == btSeparation::kFeatureBoth)
	{
		const Hull::Edge& edgeA = hullA.getEdge(sep.m_featureA);
		const Hull::Edge& edgeB = hullB.getEdge(sep.m_featureB);

		float ta, tb;
		Line la(pVertsA[edgeA.m_verts[0]], pVertsA[edgeA.m_verts[1]]);
		Line lb(pVertsB[edgeB.m_verts[0]], pVertsB[edgeB.m_verts[1]]);

		Intersect(la, lb, ta, tb);
	
#ifdef VALIDATE_CONTACT_POINTS
		AssertPointInsideHull(contact.m_points[0].m_pos, trA, hullA);
		AssertPointInsideHull(contact.m_points[0].m_pos, trB, hullB);
#endif

		
		Point3 posWorld = Lerp(la.m_start, la.m_end, ta);
		float depth = -sep.m_dist;
        Vector3 tangent = Normalize(pVertsA[edgeA.m_verts[1]] - pVertsA[edgeA.m_verts[0]]);

		sep.m_contact = hullContactCollector->BatchAddContactGroup(sep,1,normalWorld,tangent,&posWorld,&depth);
	
	}
	// face->face contact is polygon
	else
	{
		short faceA = sep.m_featureA;
		short faceB = sep.m_featureB;

		Vector3 tangent;

		// find face of hull A that is most opposite contact axis
		// TODO: avoid having to transform planes here
		if (sep.m_separator == btSeparation::kFeatureB)
		{
			const Hull::Edge& edgeB = hullB.getEdge(hullB.GetFaceFirstEdge(faceB));
			tangent = Normalize(pVertsB[edgeB.m_verts[1]] - pVertsB[edgeB.m_verts[0]]);

			Scalar dmin = Scalar::Consts::MaxValue;
			for (short face = 0; face < hullA.m_numFaces; face++)
			{
				Vector3 normal = hullA.getPlane(face).GetNormal() * trA;
				Scalar d = Dot(normal, sep.m_axis);
				if (d < dmin)
				{
					dmin = d;
					faceA = face;
				}
			}
		}
		else
		{
			const Hull::Edge& edgeA = hullA.getEdge(hullA.GetFaceFirstEdge(faceA));
			tangent = Normalize(pVertsA[edgeA.m_verts[1]] - pVertsA[edgeA.m_verts[0]]);

			Scalar dmin = Scalar::Consts::MaxValue;
			for (short face = 0; face < hullB.m_numFaces; face++)
			{
				Vector3 normal = hullB.getPlane(face).GetNormal() * trB;
				Scalar d = Dot(normal, -sep.m_axis);
				if (d < dmin)
				{
					dmin = d;
					faceB = face;
				}
			}
		}

		Point3 workspace[2][Hull::kMaxVerts];

		// setup initial clip face (minimizing face from hull B)
		int numContacts = 0;
		for (short edge = hullB.GetFaceFirstEdge(faceB); edge != -1; edge = hullB.GetFaceNextEdge(faceB, edge))
			workspace[0][numContacts++] = pVertsB[ hullB.GetEdgeVertex0(faceB, edge) ];

		// clip polygon to back of planes of all faces of hull A that are adjacent to witness face
		Point3* pVtxIn = workspace[0];
		Point3* pVtxOut = workspace[1];

#if 0
		for (short edge = hullA.GetFaceFirstEdge(faceA); edge != -1; edge = hullA.GetFaceNextEdge(faceA, edge))
		{
			Plane planeA = hullA.getPlane( hullA.GetEdgeOtherFace(edge, faceA) ) * trA;
			numContacts = ClipFace(numContacts, &pVtxIn, &pVtxOut, planeA);
		}
#else
		for (short f = 0; f < hullA.GetNumFaces(); f++)
		{
			Plane planeA = hullA.getPlane(f) * trA;
			numContacts = ClipFace(numContacts, &pVtxIn, &pVtxOut, planeA);
		}
#endif

		// only keep points that are behind the witness face
		Plane planeA = hullA.getPlane(faceA) * trA;

		float depths[Hull::kMaxVerts];
		int numPoints = 0;
		for (int i = 0; i < numContacts; i++)
		{
			Scalar d = Dot(planeA, pVtxIn[i]);
			if (IsNegative(d))
			{
				depths[numPoints] = (float)-d;
				pVtxIn[numPoints] = pVtxIn[i];

#ifdef VALIDATE_CONTACT_POINTS
					AssertPointInsideHull(pVtxIn[numPoints], trA, hullA);
					AssertPointInsideHull(pVtxIn[numPoints], trB, hullB);
#endif
				numPoints++;
			}
		}

		//we can also use a persistentManifold/reducer class
		// keep maxContacts points at most
		if (numPoints > 0)
		{
			if (numPoints > maxContacts)
			{
				int step = (numPoints << 8) / maxContacts;

				numPoints = maxContacts;
				for (int i = 0; i < numPoints; i++)
				{
					int nth = (step * i) >> 8;

					depths[i] = depths[nth];
					pVtxIn[i] = pVtxIn[nth];
					

#ifdef VALIDATE_CONTACT_POINTS
					AssertPointInsideHull(contact.m_points[i].m_pos, trA, hullA);
					AssertPointInsideHull(contact.m_points[i].m_pos, trB, hullB);
#endif
				}
			}
			
			sep.m_contact = hullContactCollector->BatchAddContactGroup(sep,numPoints,normalWorld,tangent,pVtxIn,depths);

		}
		return numPoints;
	}
Ejemplo n.º 5
0
 /// Check if the paths of @a Walker and @a Vehicle intersect.
 ///
 /// It checks if within the update time the vehicle will cross the straight
 /// line of @a Walker sight radius on its forward direction.
 static bool Intersect(const APawn &Walker, const AWheeledVehicle &Vehicle)
 {
   return Intersect(PawnPath(Walker), PawnPath(Vehicle), Walker.GetWorld());
 }
Ejemplo n.º 6
0
Intersect Model::intersect (Ray ray) const
{
	// construct return value
    real_t min_dis = 9999999.9;         // minimum distance to begin with
	Intersect result = Intersect();     // final intersect object
	result.intersect = false;           // the default value is false

    // after transformaton, the center of the object should be (0,0,0)
    Vector3 E = invMat.transform_point(ray.e);        // ray eye coordinate
    Vector3 D = invMat.transform_vector(ray.d);       // ray direction vector

    // iterate through all the mesh triangles
    for (size_t kk=0; kk<mesh->num_triangles(); kk++)
    {
        // get the three vertices of the triangle
        MeshVertex first = mesh->vertices[ mesh->triangles[kk].vertices[0] ];
        MeshVertex second = mesh->vertices[ mesh->triangles[kk].vertices[1] ];
        MeshVertex third = mesh->vertices[ mesh->triangles[kk].vertices[2] ];

        // calculate parameters for the intersection test
        real_t a = first.position.x - second.position.x;
        real_t b = first.position.y - second.position.y;
        real_t c = first.position.z - second.position.z;

        real_t d = first.position.x - third.position.x;
        real_t e = first.position.y - third.position.y;
        real_t f = first.position.z - third.position.z;

        real_t g = D.x;
        real_t h = D.y;
        real_t i = D.z;

        real_t j = first.position.x - E.x;
        real_t k = first.position.y - E.y;
        real_t l = first.position.z - E.z;

        // value cache
        real_t ei_hf = e*i - h*f;
        real_t gf_di = g*f - d*i;
        real_t dh_eg = d*h - e*g;

        real_t M = a*ei_hf + b*gf_di + c*dh_eg;

        // check t intersection
        real_t ak_jb = a*k - j*b;
        real_t jc_al = j*c - a*l;
        real_t bl_kc = b*l - k*c;
        real_t t = -( f*ak_jb + e*jc_al +d*bl_kc ) / M;

        if (t < MIN_T_THRESHOLD) {
            continue;
        }

        // check gamma intersection
        real_t gamma = ( i*ak_jb + h*jc_al + g*bl_kc ) / M;
        if (gamma < 0.0 || gamma > 1.0) {
            continue;
        }

        // check beta intersection
        real_t beta = ( j*ei_hf + k*gf_di + l*dh_eg ) / M;
        if (beta < 0.0 || beta > 1.0-gamma) {
            continue;
        }

        // calculate current position
        // get normal transformation matrix
        Matrix4 invMat_inv;
        make_transformation_matrix(&invMat_inv, position, orientation, scale);
        // calcualte world position
        Vector3 local_pos = E + t*D;
        Vector3 world_pos = invMat_inv.transform_point(local_pos);

        // need to check if this is smaller than the current min_dis
        if (distance(ray.e, world_pos) >= min_dis) {
            continue;
        }

        // reach here means intersection found, you are allowed to modify returned result

        // update distance first
        min_dis = distance(ray.e, world_pos);

        // set intersection found flag
        result.intersect = true;

        // set intersection position
        result.position = world_pos;

        // compute and set normal
        Vector3 local_norm = normalize(first.normal + second.normal + third.normal);
        result.normal = normalize(normMat * local_norm);

        // calculate texture color at this point
        if (material->texture_filename.empty()) {
            // if none of the material has texture, return white
            result.texture = Color3::White();
        }
        else 
        {
            // get texture coordinates first
            Vector2 temp_tex = first.tex_coord * (1.0-beta-gamma) + 
                               second.tex_coord * beta + 
                               third.tex_coord * gamma;
            // Bug fix: here need to solve the texture wrap problem
            temp_tex.x = temp_tex.x - floor(temp_tex.x);
            temp_tex.y = temp_tex.y - floor(temp_tex.y);
            // get the width and height
            int width, height;
            material->get_texture_size(&width, &height);
            // set the texture color
            result.texture = material->get_texture_pixel( (int)(temp_tex.x*(real_t)(width)), (int)(temp_tex.y*(real_t)(height)) ); 
        }
    }

    // this can be done outside the for loop (save time)

    // calculate ambient color
    result.ambient = material->ambient;
    // calculate diffuse color
    result.diffuse = material->diffuse;
    // calculate specular color
    result.specular = material->specular;
    // calulate refractive index
    result.refractive_index = material->refractive_index;

	// return the value
	return result;
}
Ejemplo n.º 7
0
vector<Collider2d*> Collider2d::Intersect(vec3 nPos) /// Wrapper to Intersect( Collider2d* , vec3 )
{
    return Intersect(this , nPos);
}
Ejemplo n.º 8
0
void
Region::Intersect (Rect rect)
{
	Region tmp = Region (rect);
	Intersect (&tmp);
}
Ejemplo n.º 9
0
void							btDbvtBroadphase::setAabb(		btBroadphaseProxy* absproxy,
														  const btVector3& aabbMin,
														  const btVector3& aabbMax,
														  btDispatcher* /*dispatcher*/)
{
	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
	ATTRIBUTE_ALIGNED16(btDbvtVolume)	aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
#if DBVT_BP_PREVENTFALSEUPDATE
	if(NotEqual(aabb,proxy->leaf->volume))
#endif
	{
		bool	docollide=false;
		if(proxy->stage==STAGECOUNT)
		{/* fixed -> dynamic set	*/ 
			m_sets[1].remove(proxy->leaf);
			proxy->leaf=m_sets[0].insert(aabb,proxy);
			docollide=true;
		}
		else
		{/* dynamic set				*/ 
			++m_updates_call;
			if(Intersect(proxy->leaf->volume,aabb))
			{/* Moving				*/ 

				const btVector3	delta=aabbMin-proxy->m_aabbMin;
				btVector3		velocity(((proxy->m_aabbMax-proxy->m_aabbMin)/2)*m_prediction);
				if(delta[0]<0) velocity[0]=-velocity[0];
				if(delta[1]<0) velocity[1]=-velocity[1];
				if(delta[2]<0) velocity[2]=-velocity[2];
				if	(
#ifdef DBVT_BP_MARGIN				
					m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
#else
					m_sets[0].update(proxy->leaf,aabb,velocity)
#endif
					)
				{
					++m_updates_done;
					docollide=true;
				}
			}
			else
			{/* Teleporting			*/ 
				m_sets[0].update(proxy->leaf,aabb);
				++m_updates_done;
				docollide=true;
			}	
		}
		listremove(proxy,m_stageRoots[proxy->stage]);
		proxy->m_aabbMin = aabbMin;
		proxy->m_aabbMax = aabbMax;
		proxy->stage	=	m_stageCurrent;
		listappend(proxy,m_stageRoots[m_stageCurrent]);
		if(docollide)
		{
			m_needcleanup=true;
			if(!m_deferedcollide)
			{
				btDbvtTreeCollider	collider(this);
				m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider);
				m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider);
			}
		}	
	}
}
Ejemplo n.º 10
0
/** Create view with all rows not in the given view (no dups)
 *
 * Calculates set-difference of this view minus arg view.  Result
 * is a subset, unlike c4_View::Different. Will only work if both
 * input views are sets, i.e. they have no duplicate rows in them.
 *
 * This view operation is based on a read-only custom viewer.
 */
c4_View c4_View::Minus(const c4_View &view_  ///< the second view
)const {
  // inefficient: calculate difference, then keep only those in self
  return Intersect(Different(view_));
}
Ejemplo n.º 11
0
void BruteForceTexture(int x, int y, int samps = 1000) {

   std::vector<PosFilter> _filter_elems;

   // Sub pixel sampling
   const int nthread = std::thread::hardware_concurrency();
   #pragma omp parallel for schedule(dynamic, 1)
   for(int t=0; t<nthread; ++t) {
      Random rng(t + nthread*clock());

      for(int s=0; s<samps/nthread; s++){

         // Create the RNG and get the sub-pixel sample
         float dx = rng();
         float dy = rng();

         // Generate the pixel direction
         Vector d = cx*((dx + x)/width  - .5) +
                    cy*((dy + y)/height - .5) + cam.d;
         d.Normalize();

         // Evaluate the Covariance and Radiance at the pixel location
         const auto filter = indirect_filter(Ray(cam.o, d), rng, 0, 1);
         #pragma omp critical
         {
            _filter_elems.push_back(filter);
         }
      }
   }

   // Loop over the rows and columns of the image and evaluate radiance and
   // covariance per pixel using Monte-Carlo.
   float max_ref = 0.0f;
   #pragma omp parallel for schedule(dynamic, 1), shared(max_ref)
   for (int y=0; y<height; y++){
      float max_temp = 0.0f;

      for (int x=0; x<width; x++) {
         int i=(width-x-1)*height+y;
         float _r = 0.0f;

         // Generate the pixel direction
         Vector d = cx*((0.5 + x)/width  - .5) +
                    cy*((0.5 + y)/height - .5) + cam.d;
         d.Normalize();

         Ray ray(cam.o, d);
         double t; int id;
         if(!Intersect(spheres, ray, t, id)){ continue; }
         Vector hitp = ray.o + t*ray.d;

         for(auto& elem : _filter_elems) {
            const auto& p = elem.first;
            const auto  x = Vector::Norm(hitp-p) / filterRadius;
            _r += (0.3989422804f/filterRadius) * exp(-0.5f * pow(x, 2)) * elem.second.x;
         }

         const auto scale = 20.f;
         const auto Nold  = nPassesFilter * samps;
         const auto Nnew  = (nPassesFilter+1) * samps;
         ref_img[i] = (ref_img[i]*Nold + scale*_r) / float(Nnew);
         max_temp   = std::max(ref_img[i], max_temp);
      }

      #pragma omp critical
      {
         max_ref = std::max(max_ref, max_temp);
      }
   }

   // Update the scaling
   ref_scale = 1.0f/max_ref;

   // Progressive refinement of the radius and number of passes
   filterRadius *= sqrt((nPassesFilter + 0.8) / (nPassesFilter + 1.0));
   ++nPassesFilter;
}
Ejemplo n.º 12
0
TIntersection KDTree::IntersectP(Ray &a_Ray)
{
   
    // Compute initial parametric range of ray inside kd-tree extent
    float tmin;
	TIntersection Intersect(-1,a_Ray.maxt);	
	
    if (!bounds.IntersectP(a_Ray, &tmin, &a_Ray.maxt))
    {
       return Intersect;
    }

   
	// Prepare to traverse kd-tree for ray
    Vector invDir(1.f/a_Ray.d.x, 1.f/a_Ray.d.y, 1.f/a_Ray.d.z);

	int TriangleID; 
	TIntersection test;	
	bool result = false;

#define MAX_TODO 64
    KdToDo todo[MAX_TODO];
    int todoPos = 0;
    const KdNode *node = &nodes[0];
    while (node != NULL) {
        if (node->IsLeaf()) {
            // Check for shadow ray intersections inside leaf node
            uint32_t nPrimitives = node->nPrimitives();
            if (nPrimitives == 1) {
                const KDTreePrimitiveInfo &prim = primitives[node->onePrimitive];
               
                //m_Candidates++;
				if (prim.bounds.IntersectP(a_Ray)){
						TriangleID = prim.primitiveNumber;
						//candidates++;
						if (RayTriangleTest(a_Ray.o,a_Ray.d,test,TriangleID,m_pPrimitives) && test.t<Intersect.t) {
							Intersect.t = test.t;
								Intersect.u = test.u;
								Intersect.v = test.v;
								Intersect.IDTr = TriangleID;
								result = true;
								 break;
						}
					}
				//break;
            }
            else {
                uint32_t *prims = node->primitives;
				bool tmp = false;
                for (uint32_t i = 0; i < nPrimitives; ++i) {
                    const KDTreePrimitiveInfo &prim = primitives[prims[i]];
					//m_Candidates++;
					if (prim.bounds.IntersectP(a_Ray)){
						TriangleID = prim.primitiveNumber;
						//candidates++;
						if (RayTriangleTest(a_Ray.o,a_Ray.d,test,TriangleID,m_pPrimitives) && test.t<Intersect.t) {
								Intersect.t = test.t;
								Intersect.u = test.u;
								Intersect.v = test.v;
								Intersect.IDTr = TriangleID;
								result = true;
								tmp = true;
						}
						
					}
                }
				if(tmp) break;
            }

            // Grab next node to process from todo list
            if (todoPos > 0) {
                --todoPos;
                node = todo[todoPos].node;
                tmin = todo[todoPos].tmin;
                a_Ray.maxt = todo[todoPos].maxT;
            }
            else
                break;
        }
        else {
            
            // Process kd-tree interior node

            // Compute parametric distance along ray to split plane
            int axis = node->SplitAxis();
            float tplane = (node->SplitPos() - a_Ray.o[axis]) * invDir[axis];

            // Get node children pointers for ray
            const KdNode *firstChild, *secondChild;
            int belowFirst = (a_Ray.o[axis] <  node->SplitPos()) ||
                             (a_Ray.o[axis] == node->SplitPos() && a_Ray.d[axis] >= 0);
            if (belowFirst) {
                firstChild = node + 1;
                secondChild = &nodes[node->AboveChild()];
            }
            else {
                firstChild = &nodes[node->AboveChild()];
                secondChild = node + 1;
            }

            // Advance to next child node, possibly enqueue other child
            if (tplane > a_Ray.maxt || tplane <= 0)
                node = firstChild;
            else if (tplane < tmin)
                node = secondChild;
            else {
                // Enqueue _secondChild_ in todo list
                todo[todoPos].node = secondChild;
                todo[todoPos].tmin = tplane;
                todo[todoPos].maxT = a_Ray.maxt;
                ++todoPos;
                node = firstChild;
                a_Ray.maxt = tplane;
            }
        }
    }
 
 return Intersect;
}
Ejemplo n.º 13
0
bool OctreeAccel::IntersectP(const Ray &ray) const {
	Intersection *in = new Intersection();
	return Intersect(ray, in);
}
Ejemplo n.º 14
0
void			btDbvt::benchmark()
{
	static const btScalar	cfgVolumeCenterScale		=	100;
	static const btScalar	cfgVolumeExentsBase			=	1;
	static const btScalar	cfgVolumeExentsScale		=	4;
	static const int		cfgLeaves					=	8192;
	static const bool		cfgEnable					=	true;

	//[1] btDbvtVolume intersections
	bool					cfgBenchmark1_Enable		=	cfgEnable;
	static const int		cfgBenchmark1_Iterations	=	8;
	static const int		cfgBenchmark1_Reference		=	3499;
	//[2] btDbvtVolume merges
	bool					cfgBenchmark2_Enable		=	cfgEnable;
	static const int		cfgBenchmark2_Iterations	=	4;
	static const int		cfgBenchmark2_Reference		=	1945;
	//[3] btDbvt::collideTT
	bool					cfgBenchmark3_Enable		=	cfgEnable;
	static const int		cfgBenchmark3_Iterations	=	512;
	static const int		cfgBenchmark3_Reference		=	5485;
	//[4] btDbvt::collideTT self
	bool					cfgBenchmark4_Enable		=	cfgEnable;
	static const int		cfgBenchmark4_Iterations	=	512;
	static const int		cfgBenchmark4_Reference		=	2814;
	//[5] btDbvt::collideTT xform
	bool					cfgBenchmark5_Enable		=	cfgEnable;
	static const int		cfgBenchmark5_Iterations	=	512;
	static const btScalar	cfgBenchmark5_OffsetScale	=	2;
	static const int		cfgBenchmark5_Reference		=	7379;
	//[6] btDbvt::collideTT xform,self
	bool					cfgBenchmark6_Enable		=	cfgEnable;
	static const int		cfgBenchmark6_Iterations	=	512;
	static const btScalar	cfgBenchmark6_OffsetScale	=	2;
	static const int		cfgBenchmark6_Reference		=	7270;
	//[7] btDbvt::rayTest
	bool					cfgBenchmark7_Enable		=	cfgEnable;
	static const int		cfgBenchmark7_Passes		=	32;
	static const int		cfgBenchmark7_Iterations	=	65536;
	static const int		cfgBenchmark7_Reference		=	6307;
	//[8] insert/remove
	bool					cfgBenchmark8_Enable		=	cfgEnable;
	static const int		cfgBenchmark8_Passes		=	32;
	static const int		cfgBenchmark8_Iterations	=	65536;
	static const int		cfgBenchmark8_Reference		=	2105;
	//[9] updates (teleport)
	bool					cfgBenchmark9_Enable		=	cfgEnable;
	static const int		cfgBenchmark9_Passes		=	32;
	static const int		cfgBenchmark9_Iterations	=	65536;
	static const int		cfgBenchmark9_Reference		=	1879;
	//[10] updates (jitter)
	bool					cfgBenchmark10_Enable		=	cfgEnable;
	static const btScalar	cfgBenchmark10_Scale		=	cfgVolumeCenterScale/10000;
	static const int		cfgBenchmark10_Passes		=	32;
	static const int		cfgBenchmark10_Iterations	=	65536;
	static const int		cfgBenchmark10_Reference	=	1244;
	//[11] optimize (incremental)
	bool					cfgBenchmark11_Enable		=	cfgEnable;
	static const int		cfgBenchmark11_Passes		=	64;
	static const int		cfgBenchmark11_Iterations	=	65536;
	static const int		cfgBenchmark11_Reference	=	2510;
	//[12] btDbvtVolume notequal
	bool					cfgBenchmark12_Enable		=	cfgEnable;
	static const int		cfgBenchmark12_Iterations	=	32;
	static const int		cfgBenchmark12_Reference	=	3677;
	//[13] culling(OCL+fullsort)
	bool					cfgBenchmark13_Enable		=	cfgEnable;
	static const int		cfgBenchmark13_Iterations	=	1024;
	static const int		cfgBenchmark13_Reference	=	2231;
	//[14] culling(OCL+qsort)
	bool					cfgBenchmark14_Enable		=	cfgEnable;
	static const int		cfgBenchmark14_Iterations	=	8192;
	static const int		cfgBenchmark14_Reference	=	3500;
	//[15] culling(KDOP+qsort)
	bool					cfgBenchmark15_Enable		=	cfgEnable;
	static const int		cfgBenchmark15_Iterations	=	8192;
	static const int		cfgBenchmark15_Reference	=	1151;
	//[16] insert/remove batch
	bool					cfgBenchmark16_Enable		=	cfgEnable;
	static const int		cfgBenchmark16_BatchCount	=	256;
	static const int		cfgBenchmark16_Passes		=	16384;
	static const int		cfgBenchmark16_Reference	=	5138;
	//[17] select
	bool					cfgBenchmark17_Enable		=	cfgEnable;
	static const int		cfgBenchmark17_Iterations	=	4;
	static const int		cfgBenchmark17_Reference	=	3390;

	btClock					wallclock;
	printf("Benchmarking dbvt...\r\n");
	printf("\tWorld scale: %f\r\n",cfgVolumeCenterScale);
	printf("\tExtents base: %f\r\n",cfgVolumeExentsBase);
	printf("\tExtents range: %f\r\n",cfgVolumeExentsScale);
	printf("\tLeaves: %u\r\n",cfgLeaves);
	printf("\tsizeof(btDbvtVolume): %u bytes\r\n",sizeof(btDbvtVolume));
	printf("\tsizeof(btDbvtNode):   %u bytes\r\n",sizeof(btDbvtNode));
	if(cfgBenchmark1_Enable)
	{// Benchmark 1	
		srand(380843);
		btAlignedObjectArray<btDbvtVolume>	volumes;
		btAlignedObjectArray<bool>			results;
		volumes.resize(cfgLeaves);
		results.resize(cfgLeaves);
		for(int i=0;i<cfgLeaves;++i)
		{
			volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
		}
		printf("[1] btDbvtVolume intersections: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark1_Iterations;++i)
		{
			for(int j=0;j<cfgLeaves;++j)
			{
				for(int k=0;k<cfgLeaves;++k)
				{
					results[k]=Intersect(volumes[j],volumes[k]);
				}
			}
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark1_Reference)*100/time);
	}
	if(cfgBenchmark2_Enable)
	{// Benchmark 2	
		srand(380843);
		btAlignedObjectArray<btDbvtVolume>	volumes;
		btAlignedObjectArray<btDbvtVolume>	results;
		volumes.resize(cfgLeaves);
		results.resize(cfgLeaves);
		for(int i=0;i<cfgLeaves;++i)
		{
			volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
		}
		printf("[2] btDbvtVolume merges: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark2_Iterations;++i)
		{
			for(int j=0;j<cfgLeaves;++j)
			{
				for(int k=0;k<cfgLeaves;++k)
				{
					Merge(volumes[j],volumes[k],results[k]);
				}
			}
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark2_Reference)*100/time);
	}
	if(cfgBenchmark3_Enable)
	{// Benchmark 3	
		srand(380843);
		btDbvt						dbvt[2];
		btDbvtBenchmark::NilPolicy	policy;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
		dbvt[0].optimizeTopDown();
		dbvt[1].optimizeTopDown();
		printf("[3] btDbvt::collideTT: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark3_Iterations;++i)
		{
			btDbvt::collideTT(dbvt[0].m_root,dbvt[1].m_root,policy);
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark3_Reference)*100/time);
	}
	if(cfgBenchmark4_Enable)
	{// Benchmark 4
		srand(380843);
		btDbvt						dbvt;
		btDbvtBenchmark::NilPolicy	policy;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[4] btDbvt::collideTT self: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark4_Iterations;++i)
		{
			btDbvt::collideTT(dbvt.m_root,dbvt.m_root,policy);
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark4_Reference)*100/time);
	}
	if(cfgBenchmark5_Enable)
	{// Benchmark 5	
		srand(380843);
		btDbvt								dbvt[2];
		btAlignedObjectArray<btTransform>	transforms;
		btDbvtBenchmark::NilPolicy			policy;
		transforms.resize(cfgBenchmark5_Iterations);
		for(int i=0;i<transforms.size();++i)
		{
			transforms[i]=btDbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark5_OffsetScale);
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[0]);
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt[1]);
		dbvt[0].optimizeTopDown();
		dbvt[1].optimizeTopDown();
		printf("[5] btDbvt::collideTT xform: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark5_Iterations;++i)
		{
			btDbvt::collideTT(dbvt[0].m_root,dbvt[1].m_root,transforms[i],policy);
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark5_Reference)*100/time);
	}
	if(cfgBenchmark6_Enable)
	{// Benchmark 6	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btTransform>	transforms;
		btDbvtBenchmark::NilPolicy			policy;
		transforms.resize(cfgBenchmark6_Iterations);
		for(int i=0;i<transforms.size();++i)
		{
			transforms[i]=btDbvtBenchmark::RandTransform(cfgVolumeCenterScale*cfgBenchmark6_OffsetScale);
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[6] btDbvt::collideTT xform,self: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark6_Iterations;++i)
		{
			btDbvt::collideTT(dbvt.m_root,dbvt.m_root,transforms[i],policy);		
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark6_Reference)*100/time);
	}
	if(cfgBenchmark7_Enable)
	{// Benchmark 7	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btVector3>		rayorg;
		btAlignedObjectArray<btVector3>		raydir;
		btDbvtBenchmark::NilPolicy			policy;
		rayorg.resize(cfgBenchmark7_Iterations);
		raydir.resize(cfgBenchmark7_Iterations);
		for(int i=0;i<rayorg.size();++i)
		{
			rayorg[i]=btDbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
			raydir[i]=btDbvtBenchmark::RandVector3(cfgVolumeCenterScale*2);
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[7] btDbvt::rayTest: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark7_Passes;++i)
		{
			for(int j=0;j<cfgBenchmark7_Iterations;++j)
			{
				btDbvt::rayTest(dbvt.m_root,rayorg[j],rayorg[j]+raydir[j],policy);
			}
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		unsigned	rays=cfgBenchmark7_Passes*cfgBenchmark7_Iterations;
		printf("%u ms (%i%%),(%u r/s)\r\n",time,(time-cfgBenchmark7_Reference)*100/time,(rays*1000)/time);
	}
	if(cfgBenchmark8_Enable)
	{// Benchmark 8	
		srand(380843);
		btDbvt								dbvt;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[8] insert/remove: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark8_Passes;++i)
		{
			for(int j=0;j<cfgBenchmark8_Iterations;++j)
			{
				dbvt.remove(dbvt.insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
			}
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	ir=cfgBenchmark8_Passes*cfgBenchmark8_Iterations;
		printf("%u ms (%i%%),(%u ir/s)\r\n",time,(time-cfgBenchmark8_Reference)*100/time,ir*1000/time);
	}
	if(cfgBenchmark9_Enable)
	{// Benchmark 9	
		srand(380843);
		btDbvt										dbvt;
		btAlignedObjectArray<const btDbvtNode*>	leaves;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		dbvt.extractLeaves(dbvt.m_root,leaves);
		printf("[9] updates (teleport): ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark9_Passes;++i)
		{
			for(int j=0;j<cfgBenchmark9_Iterations;++j)
			{
				dbvt.update(const_cast<btDbvtNode*>(leaves[rand()%cfgLeaves]),
					btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale));
			}
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	up=cfgBenchmark9_Passes*cfgBenchmark9_Iterations;
		printf("%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark9_Reference)*100/time,up*1000/time);
	}
	if(cfgBenchmark10_Enable)
	{// Benchmark 10	
		srand(380843);
		btDbvt										dbvt;
		btAlignedObjectArray<const btDbvtNode*>	leaves;
		btAlignedObjectArray<btVector3>				vectors;
		vectors.resize(cfgBenchmark10_Iterations);
		for(int i=0;i<vectors.size();++i)
		{
			vectors[i]=(btDbvtBenchmark::RandVector3()*2-btVector3(1,1,1))*cfgBenchmark10_Scale;
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		dbvt.extractLeaves(dbvt.m_root,leaves);
		printf("[10] updates (jitter): ");
		wallclock.reset();

		for(int i=0;i<cfgBenchmark10_Passes;++i)
		{
			for(int j=0;j<cfgBenchmark10_Iterations;++j)
			{			
				const btVector3&	d=vectors[j];
				btDbvtNode*		l=const_cast<btDbvtNode*>(leaves[rand()%cfgLeaves]);
				btDbvtVolume		v=btDbvtVolume::FromMM(l->volume.Mins()+d,l->volume.Maxs()+d);
				dbvt.update(l,v);
			}
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	up=cfgBenchmark10_Passes*cfgBenchmark10_Iterations;
		printf("%u ms (%i%%),(%u u/s)\r\n",time,(time-cfgBenchmark10_Reference)*100/time,up*1000/time);
	}
	if(cfgBenchmark11_Enable)
	{// Benchmark 11	
		srand(380843);
		btDbvt										dbvt;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[11] optimize (incremental): ");
		wallclock.reset();	
		for(int i=0;i<cfgBenchmark11_Passes;++i)
		{
			dbvt.optimizeIncremental(cfgBenchmark11_Iterations);
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	op=cfgBenchmark11_Passes*cfgBenchmark11_Iterations;
		printf("%u ms (%i%%),(%u o/s)\r\n",time,(time-cfgBenchmark11_Reference)*100/time,op/time*1000);
	}
	if(cfgBenchmark12_Enable)
	{// Benchmark 12	
		srand(380843);
		btAlignedObjectArray<btDbvtVolume>	volumes;
		btAlignedObjectArray<bool>				results;
		volumes.resize(cfgLeaves);
		results.resize(cfgLeaves);
		for(int i=0;i<cfgLeaves;++i)
		{
			volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
		}
		printf("[12] btDbvtVolume notequal: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark12_Iterations;++i)
		{
			for(int j=0;j<cfgLeaves;++j)
			{
				for(int k=0;k<cfgLeaves;++k)
				{
					results[k]=NotEqual(volumes[j],volumes[k]);
				}
			}
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark12_Reference)*100/time);
	}
	if(cfgBenchmark13_Enable)
	{// Benchmark 13	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btVector3>		vectors;
		btDbvtBenchmark::NilPolicy			policy;
		vectors.resize(cfgBenchmark13_Iterations);
		for(int i=0;i<vectors.size();++i)
		{
			vectors[i]=(btDbvtBenchmark::RandVector3()*2-btVector3(1,1,1)).normalized();
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		printf("[13] culling(OCL+fullsort): ");
		wallclock.reset();	
		for(int i=0;i<cfgBenchmark13_Iterations;++i)
		{
			static const btScalar	offset=0;
			policy.m_depth=-SIMD_INFINITY;
			dbvt.collideOCL(dbvt.m_root,&vectors[i],&offset,vectors[i],1,policy);
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	t=cfgBenchmark13_Iterations;
		printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark13_Reference)*100/time,(t*1000)/time);
	}
	if(cfgBenchmark14_Enable)
	{// Benchmark 14	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btVector3>		vectors;
		btDbvtBenchmark::P14				policy;
		vectors.resize(cfgBenchmark14_Iterations);
		for(int i=0;i<vectors.size();++i)
		{
			vectors[i]=(btDbvtBenchmark::RandVector3()*2-btVector3(1,1,1)).normalized();
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		policy.m_nodes.reserve(cfgLeaves);
		printf("[14] culling(OCL+qsort): ");
		wallclock.reset();	
		for(int i=0;i<cfgBenchmark14_Iterations;++i)
		{
			static const btScalar	offset=0;
			policy.m_nodes.resize(0);
			dbvt.collideOCL(dbvt.m_root,&vectors[i],&offset,vectors[i],1,policy,false);
			policy.m_nodes.quickSort(btDbvtBenchmark::P14::sortfnc);
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	t=cfgBenchmark14_Iterations;
		printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark14_Reference)*100/time,(t*1000)/time);
	}
	if(cfgBenchmark15_Enable)
	{// Benchmark 15	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btVector3>		vectors;
		btDbvtBenchmark::P15				policy;
		vectors.resize(cfgBenchmark15_Iterations);
		for(int i=0;i<vectors.size();++i)
		{
			vectors[i]=(btDbvtBenchmark::RandVector3()*2-btVector3(1,1,1)).normalized();
		}
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		policy.m_nodes.reserve(cfgLeaves);
		printf("[15] culling(KDOP+qsort): ");
		wallclock.reset();	
		for(int i=0;i<cfgBenchmark15_Iterations;++i)
		{
			static const btScalar	offset=0;
			policy.m_nodes.resize(0);
			policy.m_axis=vectors[i];
			dbvt.collideKDOP(dbvt.m_root,&vectors[i],&offset,1,policy);
			policy.m_nodes.quickSort(btDbvtBenchmark::P15::sortfnc);
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	t=cfgBenchmark15_Iterations;
		printf("%u ms (%i%%),(%u t/s)\r\n",time,(time-cfgBenchmark15_Reference)*100/time,(t*1000)/time);
	}
	if(cfgBenchmark16_Enable)
	{// Benchmark 16	
		srand(380843);
		btDbvt								dbvt;
		btAlignedObjectArray<btDbvtNode*>	batch;
		btDbvtBenchmark::RandTree(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale,cfgLeaves,dbvt);
		dbvt.optimizeTopDown();
		batch.reserve(cfgBenchmark16_BatchCount);
		printf("[16] insert/remove batch(%u): ",cfgBenchmark16_BatchCount);
		wallclock.reset();
		for(int i=0;i<cfgBenchmark16_Passes;++i)
		{
			for(int j=0;j<cfgBenchmark16_BatchCount;++j)
			{
				batch.push_back(dbvt.insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale),0));
			}
			for(int j=0;j<cfgBenchmark16_BatchCount;++j)
			{
				dbvt.remove(batch[j]);
			}
			batch.resize(0);
		}
		const int	time=(int)wallclock.getTimeMilliseconds();
		const int	ir=cfgBenchmark16_Passes*cfgBenchmark16_BatchCount;
		printf("%u ms (%i%%),(%u bir/s)\r\n",time,(time-cfgBenchmark16_Reference)*100/time,int(ir*1000.0/time));
	}
	if(cfgBenchmark17_Enable)
	{// Benchmark 17
		srand(380843);
		btAlignedObjectArray<btDbvtVolume>	volumes;
		btAlignedObjectArray<int>			results;
		btAlignedObjectArray<int>			indices;
		volumes.resize(cfgLeaves);
		results.resize(cfgLeaves);
		indices.resize(cfgLeaves);
		for(int i=0;i<cfgLeaves;++i)
		{
			indices[i]=i;
			volumes[i]=btDbvtBenchmark::RandVolume(cfgVolumeCenterScale,cfgVolumeExentsBase,cfgVolumeExentsScale);
		}
		for(int i=0;i<cfgLeaves;++i)
		{
			btSwap(indices[i],indices[rand()%cfgLeaves]);
		}
		printf("[17] btDbvtVolume select: ");
		wallclock.reset();
		for(int i=0;i<cfgBenchmark17_Iterations;++i)
		{
			for(int j=0;j<cfgLeaves;++j)
			{
				for(int k=0;k<cfgLeaves;++k)
				{
					const int idx=indices[k];
					results[idx]=Select(volumes[idx],volumes[j],volumes[k]);
				}
			}
		}
		const int time=(int)wallclock.getTimeMilliseconds();
		printf("%u ms (%i%%)\r\n",time,(time-cfgBenchmark17_Reference)*100/time);
	}
	printf("\r\n\r\n");
}
Ejemplo n.º 15
0
	bool Rect2f::Intersect( Math::Vector2f vec2f )const
	{
		return Intersect(vec2f.x,vec2f.y);
	}
Ejemplo n.º 16
0
void btDbvtBroadphase::performDeferredRemoval(btDispatcher* dispatcher)
{

	if (m_paircache->hasDeferredRemoval())
	{

		btBroadphasePairArray&	overlappingPairArray = m_paircache->getOverlappingPairArray();

		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());

		int invalidPair = 0;

		
		int i;

		btBroadphasePair previousPair;
		previousPair.m_pProxy0 = 0;
		previousPair.m_pProxy1 = 0;
		previousPair.m_algorithm = 0;
		
		
		for (i=0;i<overlappingPairArray.size();i++)
		{
		
			btBroadphasePair& pair = overlappingPairArray[i];

			bool isDuplicate = (pair == previousPair);

			previousPair = pair;

			bool needsRemoval = false;

			if (!isDuplicate)
			{
				//important to perform AABB check that is consistent with the broadphase
				btDbvtProxy*		pa=(btDbvtProxy*)pair.m_pProxy0;
				btDbvtProxy*		pb=(btDbvtProxy*)pair.m_pProxy1;
				bool hasOverlap = Intersect(pa->leaf->volume,pb->leaf->volume);

				if (hasOverlap)
				{
					needsRemoval = false;
				} else
				{
					needsRemoval = true;
				}
			} else
			{
				//remove duplicate
				needsRemoval = true;
				//should have no algorithm
				btAssert(!pair.m_algorithm);
			}
			
			if (needsRemoval)
			{
				m_paircache->cleanOverlappingPair(pair,dispatcher);

				pair.m_pProxy0 = 0;
				pair.m_pProxy1 = 0;
				invalidPair++;
			} 
			
		}

		//perform a sort, to sort 'invalid' pairs to the end
		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
		overlappingPairArray.resize(overlappingPairArray.size() - invalidPair);
	}
}
Ejemplo n.º 17
0
bool Sphere::All_Intersections(const Ray& ray, IStack& Depth_Stack, TraceThreadData *Thread)
{
    Thread->Stats()[Ray_Sphere_Tests]++;

    if(Do_Ellipsoid)
    {
        register int Intersection_Found;
        DBL Depth1, Depth2, len;
        Vector3d IPoint;
        BasicRay New_Ray;

        // Transform the ray into the ellipsoid's space

        MInvTransRay(New_Ray, ray, Trans);

        len = New_Ray.Direction.length();
        New_Ray.Direction /= len;

        Intersection_Found = false;

        if(Intersect(New_Ray, Center, Sqr(Radius), &Depth1, &Depth2))
        {
            Thread->Stats()[Ray_Sphere_Tests_Succeeded]++;
            if((Depth1 > DEPTH_TOLERANCE) && (Depth1 < MAX_DISTANCE))
            {
                IPoint = New_Ray.Evaluate(Depth1);
                MTransPoint(IPoint, IPoint, Trans);

                if(Clip.empty() || Point_In_Clip(IPoint, Clip, Thread))
                {
                    Depth_Stack->push(Intersection(Depth1 / len, IPoint, this));
                    Intersection_Found = true;
                }
            }

            if((Depth2 > DEPTH_TOLERANCE) && (Depth2 < MAX_DISTANCE))
            {
                IPoint = New_Ray.Evaluate(Depth2);
                MTransPoint(IPoint, IPoint, Trans);

                if(Clip.empty() || Point_In_Clip(IPoint, Clip, Thread))
                {
                    Depth_Stack->push(Intersection(Depth2 / len, IPoint, this));
                    Intersection_Found = true;
                }
            }
        }

        return(Intersection_Found);
    }
    else
    {
        register int Intersection_Found;
        DBL Depth1, Depth2;
        Vector3d IPoint;

        Intersection_Found = false;

        if(Intersect(ray, Center, Sqr(Radius), &Depth1, &Depth2))
        {
            Thread->Stats()[Ray_Sphere_Tests_Succeeded]++;
            if((Depth1 > DEPTH_TOLERANCE) && (Depth1 < MAX_DISTANCE))
            {
                IPoint = ray.Evaluate(Depth1);

                if(Clip.empty() || Point_In_Clip(IPoint, Clip, Thread))
                {
                    Depth_Stack->push(Intersection(Depth1, IPoint, this));
                    Intersection_Found = true;
                }
            }

            if((Depth2 > DEPTH_TOLERANCE) && (Depth2 < MAX_DISTANCE))
            {
                IPoint = ray.Evaluate(Depth2);

                if(Clip.empty() || Point_In_Clip(IPoint, Clip, Thread))
                {
                    Depth_Stack->push(Intersection(Depth2, IPoint, this));
                    Intersection_Found = true;
                }
            }
        }

        return(Intersection_Found);
    }
}
Ejemplo n.º 18
0
void							btDbvtBroadphase::collide(btDispatcher* dispatcher)
{
	/*printf("---------------------------------------------------------\n");
	printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
	printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
	printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
	{
		int i;
		for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
		{
			printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
				getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
		}
		printf("\n");
	}
*/



	SPC(m_profiling.m_total);
	/* optimize				*/ 
	m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
	if(m_fixedleft)
	{
		const int count=1+(m_sets[1].m_leaves*m_fupdates)/100;
		m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100);
		m_fixedleft=btMax<int>(0,m_fixedleft-count);
	}
	/* dynamic -> fixed set	*/ 
	m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
	btDbvtProxy*	current=m_stageRoots[m_stageCurrent];
	if(current)
	{
		btDbvtTreeCollider	collider(this);
		do	{
			btDbvtProxy*	next=current->links[1];
			listremove(current,m_stageRoots[current->stage]);
			listappend(current,m_stageRoots[STAGECOUNT]);
#if DBVT_BP_ACCURATESLEEPING
			m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
			collider.proxy=current;
			btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
			btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
#endif
			m_sets[0].remove(current->leaf);
			ATTRIBUTE_ALIGNED16(btDbvtVolume)	curAabb=btDbvtVolume::FromMM(current->m_aabbMin,current->m_aabbMax);
			current->leaf	=	m_sets[1].insert(curAabb,current);
			current->stage	=	STAGECOUNT;	
			current			=	next;
		} while(current);
		m_fixedleft=m_sets[1].m_leaves;
		m_needcleanup=true;
	}
	/* collide dynamics		*/ 
	{
		btDbvtTreeCollider	collider(this);
		if(m_deferedcollide)
		{
			SPC(m_profiling.m_fdcollide);
			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[1].m_root,collider);
		}
		if(m_deferedcollide)
		{
			SPC(m_profiling.m_ddcollide);
			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[0].m_root,collider);
		}
	}
	/* clean up				*/ 
	if(m_needcleanup)
	{
		SPC(m_profiling.m_cleanup);
		btBroadphasePairArray&	pairs=m_paircache->getOverlappingPairArray();
		if(pairs.size()>0)
		{

			int			ni=btMin(pairs.size(),btMax<int>(m_newpairs,(pairs.size()*m_cupdates)/100));
			for(int i=0;i<ni;++i)
			{
				btBroadphasePair&	p=pairs[(m_cid+i)%pairs.size()];
				btDbvtProxy*		pa=(btDbvtProxy*)p.m_pProxy0;
				btDbvtProxy*		pb=(btDbvtProxy*)p.m_pProxy1;
				if(!Intersect(pa->leaf->volume,pb->leaf->volume))
				{
#if DBVT_BP_SORTPAIRS
					if(pa->m_uniqueId>pb->m_uniqueId) 
						btSwap(pa,pb);
#endif
					m_paircache->removeOverlappingPair(pa,pb,dispatcher);
					--ni;--i;
				}
			}
			if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0;
		}
	}
	++m_pid;
	m_newpairs=1;
	m_needcleanup=false;
	if(m_updates_call>0)
	{ m_updates_ratio=m_updates_done/(btScalar)m_updates_call; }
	else
	{ m_updates_ratio=0; }
	m_updates_done/=2;
	m_updates_call/=2;
}
Ejemplo n.º 19
0
vector<Collider2d*> Collider2d::Intersect( Collider2d* target ) /// Wrapper to Intersect( Collider2d* , vec3 )
{
    return Intersect( target, target->owner->transform.gPosition() );
}
Ejemplo n.º 20
0
bool Shade(Path* path, Geometry *geometry, BVHAccel *bvh, const RayHit& rayHit) {

	uint tracedShadowRayCount;

	if (rayHit.index == 0xffffffffu) {
		return false;
	}

	// Something was hit
	unsigned int currentTriangleIndex = rayHit.index;
	RGB triInterpCol = geometry->triangles[currentTriangleIndex].InterpolateColor(
			geometry->vertColors, rayHit.b1, rayHit.b2);
	Normal shadeN = geometry->triangles[currentTriangleIndex].InterpolateNormal(
			geometry->vertNormals, rayHit.b1, rayHit.b2);

	// Calculate next step
	path->depth++;

	// Check if I have to stop
	if (path->depth >= MAX_PATH_DEPTH) {
		// Too depth, terminate the path
		return false;
	} else if (path->depth > 2) {

		// Russian Rulette, maximize cos
		const float p = min(1.f, triInterpCol.filter() * AbsDot(shadeN, path->pathRay.d));

		if (p > getFloatRNG(&path->seed))
			path->throughput /= p;
		else {
			// Terminate the path
			return false;
		}
	}

	//--------------------------------------------------------------------------
	// Build the shadow ray
	//--------------------------------------------------------------------------

	// Check if it is a light source
	float RdotShadeN = Dot(path->pathRay.d, shadeN);
	if (geometry->IsLight(currentTriangleIndex)) {
		// Check if we are on the right side of the light source
		if ((path->depth == 1) && (RdotShadeN < 0.f))
			path->radiance += triInterpCol * path->throughput;

		// Terminate the path
		return false;
	}

	if (RdotShadeN > 0.f) {
		// Flip shade  normal
		shadeN = -shadeN;
	} else
		RdotShadeN = -RdotShadeN;

	path->throughput *= RdotShadeN * triInterpCol;

	// Trace shadow rays
	const Point hitPoint = path->pathRay(rayHit.t);

	tracedShadowRayCount = 0;
	const float lightStrategyPdf = static_cast<float> (SHADOWRAY)
			/ static_cast<float> (geometry->nLights);

	float lightPdf[SHADOWRAY];
	RGB lightColor[SHADOWRAY];
	Ray shadowRay[SHADOWRAY];

	for (unsigned int i = 0; i < SHADOWRAY; ++i) {
		// Select the light to sample
		const unsigned int currentLightIndex = geometry->SampleLights(getFloatRNG(&path->seed));
		//	const TriangleLight &light = scene->lights[currentLightIndex];

		// Select a point on the surface
		lightColor[tracedShadowRayCount] = Sample_L(currentLightIndex, geometry, hitPoint, shadeN,
				getFloatRNG(&path->seed), getFloatRNG(&path->seed),
				&lightPdf[tracedShadowRayCount], &shadowRay[tracedShadowRayCount]);

		// Scale light pdf for ONE_UNIFORM strategy
		lightPdf[tracedShadowRayCount] *= lightStrategyPdf;

		// Using 0.1 instead of 0.0 to cut down fireflies
		if (lightPdf[tracedShadowRayCount] > 0.1f)
			tracedShadowRayCount++;
	}

	RayHit* rh = new RayHit[tracedShadowRayCount];

	for (unsigned int i = 0; i < tracedShadowRayCount; ++i)
		Intersect(shadowRay[i],  rh[i], bvh->bvhTree, geometry->triangles, geometry->vertices);

	if ((tracedShadowRayCount > 0)) {
		for (unsigned int i = 0; i < tracedShadowRayCount; ++i) {
			const RayHit *shadowRayHit = &rh[i];
			if (shadowRayHit->index == 0xffffffffu) {
				// Nothing was hit, light is visible
				path->radiance += path->throughput * lightColor[i] / lightPdf[i];
			}
		}
	}

	//--------------------------------------------------------------------------
	// Build the next vertex path ray
	//--------------------------------------------------------------------------

	// Calculate exit direction

	float r1 = 2.f * M_PI * getFloatRNG(&path->seed);
	float r2 = getFloatRNG(&path->seed);
	float r2s = sqrt(r2);
	const Vector w(shadeN);

	Vector u;
	if (fabsf(shadeN.x) > .1f) {
		const Vector a(0.f, 1.f, 0.f);
		u = Cross(a, w);
	} else {
		const Vector a(1.f, 0.f, 0.f);
		u = Cross(a, w);
	}
	u = Normalize(u);

	Vector v = Cross(w, u);

	Vector newDir = u * (cosf(r1) * r2s) + v * (sinf(r1) * r2s) + w * sqrtf(1.f - r2);
	newDir = Normalize(newDir);

	path->pathRay.o = hitPoint;
	path->pathRay.d = newDir;

	return true;
}
Ejemplo n.º 21
0
vector<Collider2d*> Collider2d::Intersect() /// Wrapper to Intersect( Collider2d* )
{
    return Intersect(this);
}
Ejemplo n.º 22
0
bool SHAPE_LINE_CHAIN::Intersects( const SHAPE_LINE_CHAIN& aChain ) const
{
    INTERSECTIONS dummy;
    return Intersect( aChain, dummy ) != 0;
}
Ejemplo n.º 23
0
// There could probably be a subroutine here, but I'll only fix it if it breaks.
bool CEntityPhysics::HitboxCollide(	const CEntityPhysics& that, 
									const CEntityTransform& thistransform,
									const CEntityTransform& thattransform) const
{
	if (m_pVertices == NULL || that.m_pVertices == NULL)
		return false;
	if (m_pVertices->size() == 0 || that.m_pVertices->size() == 0)
		return false;
	vector<CVector3>		thisboxes;
	this->GetVertices(thistransform.GetMatrix(), thisboxes);
	vector<CVector3>		thatboxes;
	that.GetVertices(thattransform.GetMatrix(), thatboxes);
	bool					intersection	= false;
	CVector3*				this_0			= &thisboxes[0];
	CVector3*				this_1			= NULL;
	CVector3*				this_2			= NULL;
	for (auto it = thisboxes.begin(); it != thisboxes.end(); it++)
	{
		if (!this_2)
		{
			this_2 = &*it;
		}
		else
		{
			this_1 = this_2;
			this_2 = &*it;
			CVector3* that_0	= &thatboxes[0];
			CVector3* that_1 = NULL;
			CVector3* that_2 = NULL;
			for (auto it2 = thatboxes.begin(); it2 != thatboxes.end(); it2++)
			{
				if (!that_2)
				{
					that_2 = &*it2;
				}
				else
				{
				that_1 = that_2;
				that_2 = &*it2;
				intersection = intersection || Intersect(*this_1,*this_2,*that_1,*that_2);
				if (intersection)
					return intersection;
				}
			}
			intersection = intersection || Intersect(*this_2,*this_0,*that_2,*that_0);
		}
	}
	CVector3* that_0	= &thatboxes[0];
	CVector3* that_1 = NULL;
	CVector3* that_2 = NULL;
	for (auto it2 = thatboxes.begin(); it2 != thatboxes.end(); it2++)
	{
		if (!that_2)
		{
			that_2 = &*it2;
		}
		else
		{
			that_1 = that_2;
			that_2 = &*it2;
			intersection = intersection || Intersect(*this_1,*this_2,*that_1,*that_2);
		}
	}
	intersection = intersection || Intersect(*this_2,*this_0,*that_2,*that_0);
	that_0	= &thatboxes[0];
	that_1 = NULL;
	that_2 = NULL;
	for (auto it3 = thatboxes.begin(); it3 != thatboxes.end(); it3++)
	{
		if (!that_2)
		{
			that_2 = &*it3;
		}
		else
		{
			that_1 = that_2;
			that_2 = &*it3;
			intersection = intersection || Intersect(thistransform.GetPosition(),this->m_PreviousPosition,*that_1,*that_2);
		}
	}
	intersection = intersection || Intersect(thistransform.GetPosition(),this->m_PreviousPosition,*that_2,*that_0);
	this_0	= &thatboxes[0];
	this_1 = NULL;
	this_2 = NULL;
	for (auto it4 = thisboxes.begin(); it4 != thisboxes.end(); it4++)
	{
		if (!this_2)
		{
			this_2 = &*it4;
		}
		else
		{
			this_1 = that_2;
			this_2 = &*it4;
			intersection = intersection || Intersect(thattransform.GetPosition(),that.m_PreviousPosition,*this_1,*this_2);
		}
	}
	intersection = intersection || Intersect(thattransform.GetPosition(),that.m_PreviousPosition,*this_2,*this_0);
	return intersection;
}
Ejemplo n.º 24
0
bool Rect< TReal >::Intersect( const Rect& r )
{
	return Intersect( r.Left, r.Top, r.Right, r.Bottom );
}