コード例 #1
0
ファイル: octree_test.cpp プロジェクト: rasmith/RayTracerX
TEST(OctreeTest, RayBoxTest) {
  BoundingBox box(glm::vec3(0.0f), glm::vec3(1.0f));
  float t_near, t_far;
  Ray ray0(glm::vec3(0.5f), glm::vec3(0.5f));
  EXPECT_TRUE(box.Intersect(ray0, t_near, t_far));
  Ray ray1(glm::vec3(0.5f, 0.5f, 0.25f), glm::vec3(0.5f));
  EXPECT_TRUE(box.Intersect(ray1, t_near, t_far));
}
コード例 #2
0
//! Check if point lays inside polygon (polygon must be in one plane)
bool Polygon3::IsPointInside(const Vector3 & pt)
{
    // Do not check if this is not a polygon
    if (pointCount <= 2)return false;

    UpdatePlaneFromPoints();

    float planeDist = plane.DistanceToPoint(pt);
    // if not on plane exit
    if (!FLOAT_EQUAL(planeDist, 0.0f))return false;

    int intersectionsCount = 0;
    Vector2 ray0(pt.x, pt.y);
    Vector2 ray1(((points[0].x + points[1].x) / 2.0f) + 1000000.0f, ((points[0].y + points[1].y) / 2.0f) + 100000.0f);

    /*
     If you enabling debug intersections do not forget to call this function inside Draw of your application.
     If you'll call it inside update or mouse or keyboard input functions you can not get any output.
     */
//#define DEBUG_DRAW_INTERSECTIONS
#if defined(DEBUG_DRAW_INTERSECTIONS)
    RenderManager::Instance()->SetColor(0.0f, 1.0f, 0.0f, 1.0f);
    RenderHelper::DrawLine(ray0, ray1);
#endif

    for (int i = 0; i < pointCount; ++i)
    {
        int32 i2 = (i == pointCount - 1) ? (0) : (i + 1);
        Vector2 pt1(points[i].x, points[i].y);
        Vector2 pt2(points[i2].x, points[i2].y);

        Vector2 result;
        if (Collisions::Instance()->IsSegmentIntersectsSegment(pt1, pt2, ray0, ray1, result))
        {

#if defined(DEBUG_DRAW_INTERSECTIONS)
            RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
            RenderHelper::DrawPoint(result, 5.0f);
#endif

            intersectionsCount++;
        }
    }
    return intersectionsCount & 1;
}
コード例 #3
0
ファイル: mesh.cpp プロジェクト: chrispap/GraphicsProject
void Mesh::calculateVolume()
{
    const float dl = mAABB[0].getXSize()/VDIV;
    if (dl<0.00001) return;

    unsigned long int voxelInside=0, voxelTotal=0, xi=0;

    for (float x= mAABB[0].min.x+dl/2; x< mAABB[0].max.x; x+=dl) {
        printf("[%c] [%-2d%%]", "|/-\\"[xi++%4], (int)(100*((x-mAABB[0].min.x)/mAABB[0].getXSize())));fflush(stdout);
        for (float y= mAABB[0].min.y+dl/2; y< mAABB[0].max.y; y+=dl) {
            for (float z= mAABB[0].min.z+dl/2; z< mAABB[0].max.z; z+=dl)
            {
                /* Construct ray */
                Point ray0(x,y,z);
                Point rayFar(x*20,y*20,z*20);
                Line ray (ray0, rayFar);

                /* Count intersecting triangles */
                set<int>alreadyIntersected;
                alreadyIntersected.clear();
                list<int>::const_iterator ti;
                int bvl = BVL;
                for (int bi=BVL_SIZE(bvl-1); bi<BVL_SIZE(bvl); ++bi) {
                    if (!Geom::intersects(mAABB[bi], ray)) continue;
                    for (ti = mAABBTriangles[bi].begin(); ti!=mAABBTriangles[bi].end(); ++ti) {
                        Triangle &t = mTriangles[*ti];
                        if ((Geom::mkcode(ray.start, t.getBox()) & Geom::mkcode(ray.end, t.getBox()))) continue;
                        if ( Geom::intersects(t, ray)) {
			    alreadyIntersected.insert(*ti);
                        }
                    }
                }
                
                ++voxelTotal;
                
		/* For odd number of triangles count this voxel to the total volume */
                if (alreadyIntersected.size()%2 == 1){
                    mVoxels.push_back( Box (Point(x-dl/2.2, y-dl/2.2, z-dl/2.2), Point(x+dl/2.2, y+dl/2.2, z+dl/2.2)));
                    ++voxelInside;
                }
            }
        }
        printf ("\r");
    }
    printf("             \r");

    /* Calculate the coverage for every AABB level */
    float objVol = (mAABB[0].getVolume()*voxelInside)/voxelTotal;
    float bVol, sVol;

    for (int bvlevel=0; bvlevel<=BVL; ++bvlevel) {
        bVol=0;
        for (int bi=BVL_SIZE(bvlevel-1); bi< BVL_SIZE(bvlevel); ++bi)
            bVol += mAABB[bi].getVolume();
	
        AABBCover[bvlevel] = objVol/bVol;
    }

    int voxelCount[BVL+1];
    for (int bvlevel=1; bvlevel<= BVL; bvlevel++) 
      voxelCount[bvlevel]=0;
    
    /* Calculate the coverage for every Sphere level */
    Box sB = mSphere[0].getBox();
    float r = mSphere[0].rad;
    float sBvol = 8.0 *r*r*r;
    voxelTotal = 0;
    
    for (float x= sB.min.x+dl/2; x< sB.max.x; x+=dl) {
	for (float y= sB.min.y+dl/2; y< sB.max.y; y+=dl) {
	    for (float z= sB.min.z+dl/2; z< sB.max.z; z+=dl) {
		++voxelTotal;
		Point v(x,y,z);
		for (int bvlevel=1; bvlevel<=BVL; ++bvlevel) {
		    for (int bi=BVL_SIZE(bvlevel-1); bi< BVL_SIZE(bvlevel); ++bi) {
			if (mSphere[bi].contains(v)) {
			    ++voxelCount[bvlevel];
			    break;
			}
		    }
		}
	    } 
	}  
    }
    
    sphereCover[0] = objVol / mSphere[0].getVolume();
    for (int bvlevel=1; bvlevel<= BVL; bvlevel++)
	sphereCover[bvlevel] = objVol / (sBvol * ((float)voxelCount[bvlevel]/voxelTotal));

}