Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » SDL2 / Rotation von Kollisionsbereichen fehlerhaft

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
01.09.2015, 15:29 Uhr
~PadMad
Gast


Hey,

Ich habe auch schon in ein anderes Forum gepostet. Dort vernehme ich leider nur Grillenzirpen. Daher hier mein nächster Versuch:

Ich arbeite momentan an einer Kollisionserkennung. Ich lege für die Models Kollisionsbereiche fest. Die fixen Kollisionsbereiche liegen im Array ppCol_rect und werden zum Verändern an ppCol_rect_copy übergeben. Momentan arbeite ich nur am "nach rechts rotieren". Beim rotieren wird zwar nach rechts rotiert aber die Kollisionsbereiche werden dabei immer wieder zusammengeschrumpft.

Gut erkennbar im Video:

http://youtu.be/_acQHu9-HDE

ppCol_rect und die Kopie davon sind Zeiger auf eine eigene Rechteck Struktur. Diese Strucktur hat einfach nur 4 Vektoren a, b, c, d, die das Rechteck beschreiben. ppCopy_rect[0]->p_a ist daher zum Beispiel der Vektor "a" der Struktur.

Methoden:

set_stuetz(): setzt den Stützvektor ^^
set_direction(): setzt den Richtungsvektor
get_stuetz_x(): gibt die x-Komponente zurück usw.
ect.

Hier der Code:


C++:
void CModel_2D::move_col_areas()
{
  int mid_x = 0;
  int mid_y = 0;
  double radiant = 0;

  d_point punkt_a;
  d_point punkt_b;
  d_point punkt_c;
  d_point punkt_d;

  // Kollisionsbereiche einfach auf der x-y-Achse verschieben

  for(int i = 0 ; i < col_area_number ; i++)
  {
    // auslesen und an buffer übergeben und verändern!

    ppCol_rect_copy[i]->p_a->set_stuetz((ppCol_rect[i]->p_a->get_stuetz_x() + pos_x), (ppCol_rect[i]->p_a->get_stuetz_y() + pos_y));
    ppCol_rect_copy[i]->p_a->set_direction(ppCol_rect[i]->p_a->get_dir_x(), ppCol_rect[i]->p_a->get_dir_y());                                           ppCol_rect_copy[i]->p_b->set_stuetz((ppCol_rect[i]->p_b->get_stuetz_x() + pos_x), (ppCol_rect[i]->p_b->get_stuetz_y() + pos_y));
    ppCol_rect_copy[i]->p_b->set_direction(ppCol_rect[i]->p_b->get_dir_x(), ppCol_rect[i]->p_b->get_dir_y());
    ppCol_rect_copy[i]->p_c->set_stuetz((ppCol_rect[i]->p_c->get_stuetz_x() + pos_x), (ppCol_rect[i]->p_c->get_stuetz_y() + pos_y));
    ppCol_rect_copy[i]->p_c->set_direction(ppCol_rect[i]->p_c->get_dir_x(), ppCol_rect[i]->p_c->get_dir_y());
    ppCol_rect_copy[i]->p_d->set_stuetz((ppCol_rect[i]->p_d->get_stuetz_x() + pos_x), (ppCol_rect[i]->p_d->get_stuetz_y() + pos_y));
    ppCol_rect_copy[i]->p_d->set_direction(ppCol_rect[i]->p_d->get_dir_x(), ppCol_rect[i]->p_d->get_dir_y());
  }

  if(current_angle != 0)
  {
    // Mit Rotation
    // aktueller Mittelpunkt des Models

    mid_x = (pos_x + (((double) pImage->getWidth()) / 2));
    mid_y = (pos_y + (((double) pImage->getHeight()) / 2));

    for(int i = 0 ; i < col_area_number ; i++)
    {
      punkt_a.x = ppCol_rect_copy[i]->p_a->get_stuetz_x();
      punkt_a.y = ppCol_rect_copy[i]->p_a->get_stuetz_y();
      punkt_b.x = ppCol_rect_copy[i]->p_b->get_stuetz_x();
      punkt_b.y = ppCol_rect_copy[i]->p_b->get_stuetz_y();
      punkt_c.x = ppCol_rect_copy[i]->p_c->get_stuetz_x();
      punkt_c.y = ppCol_rect_copy[i]->p_c->get_stuetz_y();
      punkt_d.x = ppCol_rect_copy[i]->p_d->get_stuetz_x();
      punkt_d.y = ppCol_rect_copy[i]->p_d->get_stuetz_y();

      radiant = current_angle * (PI / 180);

      if(rot_dir == CMODEL_2D_ROTATE_RIGHT)
      {
        punkt_a.x = mid_x + (punkt_a.x - mid_x) * cos(radiant) - (punkt_a.y - mid_y) * sin(radiant);
        punkt_a.y = mid_y + (punkt_a.x - mid_x) * sin(radiant) + (punkt_a.y - mid_y) * cos(radiant);
        punkt_b.x = mid_x + (punkt_b.x - mid_x) * cos(radiant) - (punkt_b.y - mid_y) * sin(radiant);
        punkt_b.y = mid_y + (punkt_b.x - mid_x) * sin(radiant) + (punkt_b.y - mid_y) * cos(radiant);
        punkt_c.x = mid_x + (punkt_c.x - mid_x) * cos(radiant) - (punkt_c.y - mid_y) * sin(radiant);
        punkt_c.y = mid_y + (punkt_c.x - mid_x) * sin(radiant) + (punkt_c.y - mid_y) * cos(radiant);
        punkt_d.x = mid_x + (punkt_d.x - mid_x) * cos(radiant) - (punkt_d.y - mid_y) * sin(radiant);
        punkt_d.y = mid_y + (punkt_d.x - mid_x) * sin(radiant) + (punkt_d.y - mid_y) * cos(radiant);
      }

      ppCol_rect_copy[i]->p_a->set_stuetz(punkt_a.x, punkt_a.y);
      ppCol_rect_copy[i]->p_b->set_stuetz(punkt_b.x, punkt_b.y);
      ppCol_rect_copy[i]->p_c->set_stuetz(punkt_c.x, punkt_c.y);
      ppCol_rect_copy[i]->p_d->set_stuetz(punkt_d.x, punkt_d.y);

      ppCol_rect_copy[i]->p_a->set_direction((punkt_b.x - punkt_a.x), (punkt_b.y - punkt_a.y));
      ppCol_rect_copy[i]->p_b->set_direction((punkt_c.x - punkt_b.x), (punkt_c.y - punkt_b.y));
      ppCol_rect_copy[i]->p_c->set_direction((punkt_d.x - punkt_c.x), (punkt_d.y - punkt_c.y));
      ppCol_rect_copy[i]->p_d->set_direction((punkt_a.x - punkt_d.x), (punkt_a.y - punkt_d.y));
    }
  }
}



Momentan verstehe ich nicht, warum es nicht geht. Den selben Rotationsalgorithmus habe ich im Hauptmenü und da funktioniert er augenscheinlich.

Jede Hilfe wäre hier super.

Gruß,
Patrick

Dieser Post wurde am 01.09.2015 um 21:03 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
01.09.2015, 21:06 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


naja dem video nach sieht es fast so aus als würdest du um die falsche achse zu rotieren?

Ansonsten: warum nutzt du nicht eine matrixbibliothek (z.b eigen, armadillo, o.ö) für die rotationsgeschichten, das macht einem das einfacher weil man nicht sich selbst um das ganze "geometrie-mathe" kümmern muss
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
01.09.2015, 21:29 Uhr
~PadMad
Gast


Naja, es gibt nur einen fixen Mittelpunkt des Models. Also mid_x und mid_y. Die sind konstant vor dem Schleifenaufruf festgelegt. Da stimmt eher irgendwas mit der Kreisbahn nicht. Aber es dreht sich ja vom Mittelpunkt ausgehend immer konstant falsch. Richtung stimmt aber. Bei schnelleren Asteroiden wirkt das meist nur so, als würden sie sich nach links drehen. Dem ist aber meines Erachtens nicht so.

Die Bibliotheken schaue ich mir mal an. Aber das kann doch nicht alleine so schwer sein etwas zu rotieren. Muss nur gucken, ob das mit SDL hinhaut.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: