Gewissensfrage

RenéG

Kugeln und Quader sind nur spezielle geometrische Objekte, mit denen es aufgrund weniger Parameter und einer simplen Gleichung möglich ist, die Lage im Raum zu bestimmen.
Wie sieht es denn bei Deiner Kugelformel aus, wenn sie bei 2/3. abgeschnitten wurde?

TS++

Wie sieht es denn bei Deiner Kugelformel aus, wenn sie bei 2/3. abgeschnitten wurde?

Ist mir ehrlich gesagt nicht so ganz klar, was du damit meinst!

Grüße,
TS++

Jester

Du suchst scheinbar sowas wie eine virtuelle Methode, die aber anhand von zwei oder mehr Objekten ausgewählt wird. Sowas läuft glaub ich unter dem Stichwort double-dispatching. => Google hilft.

PeterTheMaster

du kommst um einen downcast nicht herum. den kannst du aber schick hinter einem visitor mechanismus verstecken.
dabei abstrahierst du gleichzeitig vom container, und einen baum von aussen zu durchwandern ist ja auch nicht so ganz ohne, und wenn man das in verschiedenen zusammenhaengen macht, hat man einen haufen unuebersichtlicher schleifen, die man nicht braucht.

TS++

Erstmal: Danke Jester, bin noch am RumGooglen!

@PeterTheMaster:
Was meinst du denn bitte genau mit visitor mechanismus?

Grüße,
TS++

Harrison Bergeron

Original erstellt von TS++:
Was meinst du denn bitte genau mit visitor mechanismus?

Ich vermute er meint das Visitor Pattern.

TS++

@all:
Danke euch für eure Antworten!

Grüße,
TS++

kartoffelsack

Nur ein Entwurf, nicht kompiliert und nur 2x durchgelesen
Erklärung folgt bei Bedarf morgen

//Funktionen zur Überprüfung der Kollision

 bool
ChckCollision( CGlobe& , CGlobe&);

 bool
ChckCollision( CGlobe& , CCube&);

/* abstrakte Basisklasse für Kollisionsüberprüfungsklassen*/
 class
CCollisionChecker
{
public:
  /** - */
   virtual
   bool
  ChckCollision( CGlobe&) = 0;

  /** - */
   virtual
   bool
  ChckCollision( CCube&) = 0;
};

/* CollisionChecker-Klasse für Vergleiche mit Globes*/
 class
CGlobeCollisionChecker
:public CCollisionChecker
{
   CGlobe&
  m_Globe;

public:

  CGlobeCollisionChecker(CGlobe& Globe)
  :m_Globe(Globe)
  {
  }

   bool
  ChckCollision( CGlobe& Other)
  {
    ChckCollision( m_Globe, Other);
  }

   bool
  ChckCollision( CCube& Other)
  {
    ChckCollision( m_Globe, Other);
  }

};

/* CollisionChecker-Klasse für Vergleiche mit Cubes*/
 class
CCubeCollisionChecker
:public CCollisionChecker
{
   CCube&
  m_Cube;

public:

  CGlobeCollisionChecker(CCube& Globe)
  :m_Globe(Globe)
  {
  }

   bool
  ChckCollision( CGlobe& Other)
  {
    ChckCollision( m_Cube, Other);
  }

   bool
  ChckCollision( CCube& Other)
  {
    ChckCollision( m_Cube, Other);
  }

};

/** Basisklasse für Körper*/
 class
CGeometricBody
{
public:

   bool
  ChckCollision( CGeometricBody& OtherBody)
  {
     std::auto_ptr<CCollisionChecker>
    CollisionChecker( GenCollisionChecker());

    return OtherBody.PerfCollisionCheck( *CollisionChecker);
  }

protected:

   virtual
   std::auto_ptr<CCollisionChecker>
  GenCollisionChecker() = 0;

   virtual
   std::auto_ptr<CCollisionChecker>
  PerfCollisionCheck( CCollisionChecker& ) = 0;

};

//Implementationen konkreter Körper
 class
CGlobe
:public CGeometricBody
{

protected:

   virtual
   std::auto_ptr<CCollisionChecker>
  GenCollisionChecker()
  {
    return new (CGlobeCollisionChecker(*this));
  }

   virtual
   std::auto_ptr<CCollisionChecker>
  PerfCollisionCheck( CCollisionChecker& )
  {
    return CCollisionChecker.ChckCollision(*this));
  }

};

//Implementationen konkreter Körper
 class
CCube  
:public CGeometricBody
{

protected:

   virtual
   std::auto_ptr<CCollisionChecker>
  GenCollisionChecker()
  {
    return new (CCubeCollisionChecker(*this));  )
  }

   virtual
   std::auto_ptr<CCollisionChecker>
  PerfCollisionCheck( CCollisionChecker& )
  {
    return CCollisionChecker.ChckCollision(*this));
    //bin mir nicht sicher: könnte
    //das nicht auch in die 
    //Basisklasse? (d.h. hat this in
    //der Basisklasse den Typ der
    //der konkreten Ableitung?)
  }

};

[ Dieser Beitrag wurde am 08.07.2003 um 22:31 Uhr von kartoffelsack editiert. ]

[ Dieser Beitrag wurde am 09.07.2003 um 12:06 Uhr von kartoffelsack editiert. ]

TS++

Morgen kartoffelsack!

bool CGeometricBody::ChckCollision( CGeometricBody& secondBody )
{
    std::auto_ptr<CCollisionChecker> 
    CollisionChecker( GenCollisionChecker());
    return PerfCollisionCheck( *CollisionChecker);
}

Wo verwertest du denn die Referenz auf den GeometricBody, gegen den getestet werden soll?
Ich müsste, wenn schon, dann von secondBody einen CollisionChecker anfordern und auf diesen dann 'PerfCollisionCheck' anwenden.

Ach übrigens:
(Gehört zwar eigentlich in ein anderes Forum)
Ich bin jetzt auf ein Konzept zur Kollisionskontrolle gestossen, das es nicht mehr erforderlich macht, den exakten Typen des jeweiligen Volumes zu kennen.
Nennt sich: Separating Axis Theorem (unter Gamasutra)
Jedoch was die Effizienz anbelangt, bin ich mir noch nicht so ganz sicher.

Das DownCast-Problem kann natürlich bei anderen Fallbeispielen, als dem aktuellen, mit diesem Theorem nicht gelöst werden, klar!

Grüße,
TS++

RenéG

@TS++
Zu meinem letzten Beitrag, schau Dir mal das an: http://www-sst.informatik.tu-cottbus.de/~wk/cg_v08b.pdf

kartoffelsack

@TS++
Jo, hast recht. Habs ausgebessert