2D CSG implementieren (für Kollisionsformen)?

Gibt es einfache (oder gut dokumentierte) Algorithmen für grundlegende CSG-Operationen an 2D-Polygonen?

Ich suche nach einer Möglichkeit, eine Reihe überlappender 2D-Kollisionsformen hinzuzufügen. Diese können konvex oder konkav sein, sind jedoch geschlossene Formen, definiert als eine Reihe von Liniensegmenten ohne Selbstschnittpunkte.

Die Verwendung davon wäre, einen sauberen Satz von Kollisionskanten zur Verwendung mit einer 2D-Physik-Engine aus einer Szene zu konstruieren, die aus vielen willkürlich platzierten (und häufig überlappenden) Objekten besteht, von denen jedes seine eigene Kollisionsform hat.

Zunächst muss ich nur Formen hinzufügen, aber die Fähigkeit zum Subtrahieren und Erstellen von Löchern kann auch nützlich sein.

Ist das für Level Designer oder für den Motor?

Für den Level-Designer benötigen Sie diesen Code, um z. B. statische Objekte zu kombinieren. Erforschen Sie vektorgrafische APIs für die Lösung. Die Aufgabe klingt für SVG, PostScript, WMF usw. ziemlich häufig. Versuchen Sie zuerst, die CombineRgn Win32-API zu verwenden :-)

Für die Spiel-Engine - ich würde vorschlagen, dass Sie nicht tun, was Sie wollen. Sie werden enorm viel CPU aufwenden, um Ihre Objekte miteinander zu kombinieren. Sie werden eine enorme Anzahl von Verzweigungsfehlvorhersagen damit verbringen, die Randbedingungen zu überprüfen, zu testen, ob sich 2 Segmente schneiden oder nicht usw. Dieser Vorgang muss in jedem Frame für den sichtbaren Teil Ihrer Karte wiederholt werden.

Führen Sie einfach Bounding-Box-Checks durch und kollidieren Sie dann mit einzelnen Objekten. Wenn Ihre Objektformen zu komplex sind, vereinfachen Sie sie beim Exportieren von Daten in die Engine und verwenden Sie verschiedene Formen für Kollisionen und Zeichnungen.

Update : Siehe meinen C # GDI + Code, der macht, was Sie wollen. Sie können dasselbe problemlos in C ++ schreiben: Die GraphicsPath-Klasse ist lediglich ein Thin Wrapper über die entsprechenden Funktionen von gdiplus.dll.

static class GraphicsPathExt
{
    [DllImport( @"gdiplus.dll" )]
    static extern int GdipWindingModeOutline( HandleRef path, IntPtr matrix, float flatness );

    static HandleRef getPathHandle( GraphicsPath p )
    {
        return new HandleRef( p, (IntPtr)p.GetType().GetField( "nativePath", BindingFlags.NonPublic | BindingFlags.Instance ).GetValue( p ) );
    }

    public static void FlattenPath( this GraphicsPath p )
    {
        HandleRef h = getPathHandle( p );
        int status = GdipWindingModeOutline( h, IntPtr.Zero, 0.25F );
        // TODO: see http://msdn.microsoft.com/en-us/library/ms534175(VS.85).aspx and throw a correct exception.
        if( 0 != status )
            throw new ApplicationException( "GDI+ error " + status.ToString() );
    }
}

class Program
{

    static void Main( string[] args )
    {
        PointF[] fig1 = 
        {
            new PointF(-50, 0),
            new PointF(0, 50),
            new PointF(50, 0),
        };

        PointF[] fig2 = 
        {
            new PointF(-50, 25),
            new PointF(50, 25),
            new PointF(0, -25),
        };

        GraphicsPath path1 = new GraphicsPath();
        path1.AddLines( fig1 );
        path1.CloseAllFigures();

        GraphicsPath path2 = new GraphicsPath();
        path2.AddLines( fig2 );
        path2.CloseAllFigures();

        GraphicsPath combined = new GraphicsPath();
        combined.AddPath( path1, true );
        combined.AddPath( path2, true );
        combined.FlattenPath();

        foreach (var p in combined.PathPoints)
        {
            Console.WriteLine( "<{0}, {1}>", p.X, p.Y );
        }
    }
}

Ich habe einen kleinen Proof of Concept geschrieben, der CSG verwendet hat, um das Spiel im Stil von Scorched Earth / Worms zu verbessern. Ich habe es mit gluTessellate implementiert . Ich habe dann die tessellierten Dreiecke auf Box2D-Polygone abgebildet. Ich konnte sowohl Schmutz zur Simulation hinzufügen und daraus entfernen als auch Löcher bohren und füllen.

Das größte Problem bei der Verwendung von gluTessallate ist, dass es kein Problem gibt, entartete Dreiecke zurückzugeben. Ich musste diese herausfiltern, bevor ich die tessellierten Dreiecke in die Physik-Engine verschob.

Eines der schönen Dinge an gluTessallate ist, dass es möglich ist, die Nachbarschaft aus den Rückrufinformationen zu bestimmen. Ich bin nie weiter gegangen, aber theoretisch könnte man die Nachbarschaft und den SCC verwenden , um Inselbildung genau zu erkennen.