ZFX + Developia

Code: Alles auswählen

bool geometryTest(const line2d& l1, const line2d& l2, const f32 tolerance)
{
    // TODO : Improve speed e.g. remove square roots..
    // TODO : this is optimised for short lines. Fix it for longer ones

	f32 len1 = l1.getLength();
	f32 len2 = l2.getLength();

	vector2df d1 = (l1.End-l1.Start) / len1;
	vector2df d2 = (l2.End-l2.Start) / len2;

	for(f32 i = 0; i <= len1; i += 0.1f)
		for(f32 j = 0; j <= len2; j += 0.1f)
		{
			vector2df p1 = l1.Start + d1 * i;
			vector2df p2 = l2.Start + d2 * j;

			if(distanceSquared(p1, p2) < sqr(0.1f+tolerance))
				return true;
		}

	return false;
}

Code: Alles auswählen

vector2df getNormal(const line2d& line)
{
    vector2df dir = line.getDirection();
    vector2df normal(-dir.Y, dir.X);
    normal.normalize();

    return normal;
}

vector<line2d> toLines(const line2d& line, f32 border)
{
    vector2df normal = getNormal(line);

    vector2df p1 = line.Start + normal * border;
    vector2df p2 = line.Start - normal * border;
    vector2df p3 = line.End + normal * border;
    vector2df p4 = line.End - normal * border;

    return {line2d(p1, p2), line2d(p2, p3), line2d(p3, p4), line2d(p4, p1)};
}

Code: Alles auswählen

bool geometryTest(const vector<line2d>& lines1, const vector<line2d>& lines2)
{
    // start of the projection ray,
    // doesn't actually matter where it is
    vector2df ray_start(0,0);

    vector<vector2df> directions = getDirections(lines1, lines2);

    for(auto direction: directions)
    {
        vector2df normal = getNormal(direction);
        ray2d proj_ray(ray_start, normal);

        vector<vector2df> points1;
        vector<vector2df> points2;

        for(auto it : lines1)
        {
            ray2d cur_ray1(it.Start, direction);
            ray2d cur_ray2(it.End, direction);

            pair<bool, vector2df> int1 = cur_ray1.intersection(proj_ray);
            pair<bool, vector2df> int2 = cur_ray2.intersection(proj_ray);

            if(int1.first)
                points1.push_back(int1.second);

            if(int2.first)
                points1.push_back(int2.second);

        }

        for(auto it : lines2)
        {
            ray2d cur_ray1(it.Start, direction);
            ray2d cur_ray2(it.End, direction);

            pair<bool, vector2df> int1 = cur_ray1.intersection(proj_ray);
            pair<bool, vector2df> int2 = cur_ray2.intersection(proj_ray);

            if(int1.first)
                points2.push_back(int1.second);

            if(int2.first)
                points2.push_back(int2.second);
        }

        rect2df bounds1 = getBoundaries(points1);
        rect2df bounds2 = getBoundaries(points2);

        if(!geometryTest(bounds1, bounds2))
            return false;
    }

    // no gap found
    return true;
}

Code: Alles auswählen

bool KollisionstestLinienMitDicke(CLinie *linie1, CLinie *linie2)
{
	// Schritt 1: Linien als Geraden betrachten
	CGerade *gerade1 = new CGerade(linie1->richtung, linie1->startpunkt);
	CGerade *gerade2 = new CGerade(linie2->richtung, linie2->startpunkt);
	if(gerade1->ParallelZu(gerade2))
	{
		if(gerade1->AbstandZu(gerade2) > (linie1->dicke+linie2->dicke))
		{
			delete gerade1;
			delete gerade2;
			return false;
		}
	}
	else // Geraden schneiden sich => prüfen ob auch die Linien das auch tun
	{
		float fAbstand1, fAbstand2, fMinAbstand;
		bool bKollision = false;

		// ------------------------------------------------
		// gerade1 und linie2 auf Kollision prüfen
		fAbstand1 = gerade1->AbstandZuPunkt(linie2->startpunkt);
		fAbstand2 = gerade1->AbstandZuPunkt(linie2->Endpunkt);

		// Punkte müssen auf beiden Seiten der Gerade liegen
		if(fAbstand1 <= 0 && fAbstand2 >= 0 || fAbstand1 >= 0 && fAbstand2 <= 0)
			bKollision = true; // Sagt noch nicht so viel aus

		// jetzt noch Dicke beachten
		if(!bKollision)
		{
			fMinAbstand = min(abs(fAbstand1), abs(fAbstand2));
			// Wenn hier keine Kollision stattgefunden hat, dann kann man direkt aussteigen
			if(fMinAbstand > linie1->dicke + linie2->dicke * 0.5f)
			{
				delete gerade1;
				delete gerade2;
				return false;
			}
		}

		// ------------------------------------------------------------------------------------------------------------------------
		// gerade1 und linie2 ergaben eine Kollision, jetzt noch umgekehrten Fall prüfen (linie1 mit gerade2)
		fAbstand1 = gerade2.AbstandZuPunkt(linie1.startpunkt);
		fAbstand2 = gerade2.AbstandZuPunkt(linie1.Endpunkt);

		// Punkte müssen auf beiden Seiten der Gerade liegen
		if(fAbstand1 <= 0 && fAbstand2 >= 0 || fAbstand1 >= 0 && fAbstand2 <= 0)
			bKollision = true; // Sagt noch nicht so viel aus

		// jetzt noch Dicke beachten
		if(!bKollision)
		{
			fMinAbstand = min(abs(fAbstand1), abs(fAbstand2));
			// Wenn hier keine Kollision stattgefunden hat, dann kann man direkt aussteigen
			if(fMinAbstand > linie1.dicke*0.5f + linie2.dicke)
			{
				delete gerade1;
				delete gerade2;
				return false;
			}
		}
	}

	delete gerade1;
	delete gerade2;

	// Da der Kollisionstest nicht vorzeitig beendet wurde schneiden sich die Linien (oder berühren sich zumindest)
	return true;
}