3. Gewissensfrage

Gewissensfrage

  • R

    Und genau das ist das Problem! Bei einer Kollisionskontrolle muss genau bekannt sein, welche Volumes überprüft werden (Sphere<->Box,Sphere<->Sphere,Box<->Box,Box<->Sphere).

    Falsch. Beim Implementieren einer gemeinsamen Klasse müssen Eigenschaften dieser Objekte bekannt sein, die überall die Gleichen sind.
    Das bedeutet, dass TBoundingVolume nicht wissen muss, ob es sich um eine Sphere oder eine Box handelt. Einzig und allein die Position im 3dimensionalen Raum bleibt übrig, nicht die Form.
    Als Beispiel könnte man ein Objekt 3DRegion bilden, welches sämtliche Volumenelemente (Würfel) enthält. Als Grundlage würde dann hier ein Tree dienen, um das Ganze effizient zu gestalten. Jetzt wird also bei testAgainst nur noch Tree1 mit Volumenelementen gegen Tree2 mit Volumenelementen getestet.

    0
  • T

    Hallo!

    Nur bei Spheres wird die quadrierte Distanz zwischen den beiden Zentralvektoren der betroffenen Spheres und die Summe der Radien herangezogen um eine Kollisionskontrolle durchzuführen.
    ==> erforderlich: Zentralvektor, Radius

    Bei Boxen bedient man sich ja der Ebenengleichung: Ax + By + Cz = d
    Und dies für alle 6 Seiten der Box
    ==> erforderlich: Normalenvektor der Ebene zur innenseite der Box, Abstand der Ebene zum Koordinatenursprung

    Und diese Volumes können nun in 4 unterschiedlichen Varianten aufeinandertreffen. Wie soll ich denn das in eine neutrale VolumesKlasse packen?

    Grüße,
    TS++

    0
  • R

    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?

    0
  • T

    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++

    0
  • J

    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.

    0
  • P

    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.

    0
  • T

    Erstmal: Danke Jester, bin noch am RumGooglen! 😉

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

    Grüße,
    TS++

    0
  • H

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

    Ich vermute er meint das Visitor Pattern.

    0
  • T

    @all:
    Danke euch für eure Antworten!

    Grüße,
    TS++

    0
  • K

    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. ]

    0
  • T

    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++

    0
  • R

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

    0
  • K

    @TS++
    Jo, hast recht. Habs ausgebessert

    0
Anmelden zum Antworten