ich wollte eine Klassenhierarchie erstellen die Bounding Volumes umfasst um mit diesen dann Schnitttests durchzuführen. Die Methoden für die Schnitttests untereinander wollte ich gern in die Unterklassen packen, nur bin ich dabei auf ein Entwurfs-Problem gestoßen bei dem mir keine richtig schöne Lösung einfällt.
Bei der Suche nach verwandten Problemen bin ich leider auch nicht fündig geworden, drum der Post hier.

Das Szenario sieht folgendermaßen aus:

class BVolume{
  ...
  virtual bool intersect(BVolume *opponent) = 0;
}

class OBB : BVolume{
  ...
}

class BSphere : BVolume{
  ...
}

class AABB : BVolume{
  ...
}

Was ich brauche ist die Implementierung der "intersect"-Funktion mit allen möglichen Permutationen der einzelnen Bounding-Volume-Unterklassen ohne dabei Code zu duplizieren.
Also OBB<->OBB, OBB<->BSphere, OBB<->AABB, BSphere<->BSphere, BSphere<->AABB, AABB<->AABB. Die Schnitttests für alle diese Kombinationen müssen implementiert werden. Ich finde einfach keine Möglichkeit die Implementierungen so zu verteilen, dass ich sie nicht 3-fach in allen 3 Unterklassen stehen hab.

Ich möchte die Funktion deswegen gern auf die Unterklassen verteilen, weil ich an einer anderen Stelle diverse Listen durchlaufe die BVolumes speichern und ich dann mit einem einzigen Aufruf den Schnitt untereinander durch die dynamische Typprüfung zur Laufzeit durchführen könnte.

Derzeit hab ich die intersect-Funktion komplett aus der Klassenhierarchie ausgelagert und mit den verschiedenen Unterklassen als Parameter überladen:

bool intersect(OBB*,OBB*);
bool intersect(OBB*,BSphere*);
bool intersect(OBB*,AABB*);
bool intersect(BSphere*,BSphere*);
bool intersect(BSphere*,AABB*)
bool intersect(AABB*,AABB*);

Das gefällt mir aber eigentlich gar nicht, weil ich dadurch extra eine Variable in der Oberklasse einführen musste die mir den Typ speichert. Mit Hilfe der Variable muss ich bis jetzt beim Durchlaufen der BVolumes in der Liste eine hässliche If-Kaskade durchlaufen, bevor ich die richtige Methode für den Schnitttest aufrufen kann. Außerdem sind diverse Downcasts nötig die ich auch gern vermeiden würde.

Hat irgendwer nen Tipp für mich wie ich die intersect-Methode wie gewollt in die Unterklassen einbauen kann um einen Schnitttest mittels Typprüfung zur Laufzeit zu erlauben?
Templates wären mir auch recht, wenn dabei eine äquivalente Lösung zustande käme.

Danke schonmal im Voraus fürs grübeln.

C++ kann das von sich aus nicht, aber man kann es mit zwei normalen virtual Function Calls nachbilden:

bool intersect(OBB*,OBB*); 
bool intersect(OBB*,BSphere*); 
bool intersect(OBB*,AABB*); 
bool intersect(BSphere*,BSphere*); 
bool intersect(BSphere*,AABB*) 
bool intersect(AABB*,AABB*);

class OBB;
class BSphere;
class AABB;

class BVolume { 
   ... 
   virtual bool intersect(BVolume *opponent) = 0;
   virtual bool intersect(OBB *opponent) = 0;
   virtual bool intersect(BSphere *opponent) = 0;
   virtual bool intersect(AABB *opponent) = 0;
} 

inline bool intersect(BVolume* a, BVolume* b) {
    return a->intersect(b); // Dispatch by type of first object (a)
}

class OBB : BVolume {
   virtual bool intersect(BVolume *opponent) {
       return opponent->intersect(this); // Dispatch by type of second object (opponent aka. b)
   }

   virtual bool intersect(OBB *opponent) {
       return intersect(this, opponent); // Call suitable overload of free intersect() function
   }

   virtual bool intersect(BSphere *opponent) {
       return intersect(this, opponent); // ...
   }

   virtual bool intersect(AABB *opponent) {
       return intersect(this, opponent); // ...
   }
} 

class BSphere : BVolume {
   virtual bool intersect(BVolume *opponent) {
       return opponent->intersect(this); // Dispatch by type of second object (opponent aka. b)
   }

   virtual bool intersect(OBB *opponent) {
       return intersect(opponent, this);
   }

   virtual bool intersect(BSphere *opponent) {
       return intersect(this, opponent);
   }

   virtual bool intersect(AABB *opponent) {
       return intersect(this, opponent);
   }
} 

class AABB : BVolume {
   virtual bool intersect(BVolume *opponent) {
       return opponent->intersect(this); // Dispatch by type of second object (opponent aka. b)
   }

   virtual bool intersect(OBB *opponent) {
       return intersect(opponent, this);
   }

   virtual bool intersect(BSphere *opponent) {
       return intersect(opponent, this);
   }

   virtual bool intersect(AABB *opponent) {
       return intersect(this, opponent);
   }
}

Das gewinnt jetzt keinen Schönheitswettbewerb, aber es funktioniert.

Könnte aber leicht sein dass du mit der Typ-Variable schneller bist. Die if-Kaskade könnte man durch ein Array mit Funktionszeigern ersetzen. Dann rechnest du einfach index = type1 * numberOfTypes + type2 und rufst darüber die passende Funktion auf. Das ist dann ein indirekter Aufruf statt zwei, also vermutlich ne Spur schneller.