Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Separating Axis Theorem - Minimum Translation Vector

Werbeanzeige

JasonB

Frischling

  • »JasonB« ist der Autor dieses Themas

Beiträge: 15

  • Private Nachricht senden

1

30.01.2011, 07:48

Separating Axis Theorem - Minimum Translation Vector

Hallo zusammen,
wie berechne ich den mtvector? >< hab schon gegooglet und alles versucht.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// hier wird auf kollision geprüft

        if(player_xAxis_min > box_xAxis_max || player_xAxis_max < box_xAxis_min)
        {
            //
        }
        else
        {
            if(player_yAxis_min > box_yAxis_max || player_yAxis_max < box_yAxis_min)
            {
                //
            }
            else
            {
                // kollision
                // muss ich den hier berechnen & wie?
            }
        }


Alles 2D. Bitte hilft mir! Danke

-mfg JasonB

Nox

Supermoderator

Beiträge: 5 272

Beruf: Student

  • Private Nachricht senden

2

30.01.2011, 16:25

Könntest du ggf. mehr Infos rausrücken? Wie ist denn dein "Minimum Translation Vector" definiert? Wozu brauchst du diesen Vektor?
PRO Lernkurs "Wie benutze ich eine Doku richtig"!
CONTRA lasst mal die anderen machen!
networklibbenc - Netzwerklibs im Vergleich | syncsys - Netzwerk lib (MMO-ready) | Schleichfahrt Remake | Firegalaxy | Sammelsurium rund um FPGA&Co.

JasonB

Frischling

  • »JasonB« ist der Autor dieses Themas

Beiträge: 15

  • Private Nachricht senden

3

30.01.2011, 18:44

diesen brauch ich für den response wenn 2 boxe kollidieren damit ich sie trennen kann.

das is mein code für die berechnungen, die boxen werden nicht rotiert. player is auch ein box.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

        D3DXVECTOR2 box_xAxis[2];                                                         // [0] steht für min [1] ist max
        calcProj(box_xAxis, D3DXVECTOR2(1.0f, 0.0f), box_drawVertices);     // vertices auf die X axis proj.
        D3DXVECTOR2 box_yAxis[2];                                                       // [0] steht für min [1] ist max
        calcProj(box_yAxis, D3DXVECTOR2(0.0f, 1.0f), box_drawVertices);     // vertices auf die Y axis proj.

        D3DXVECTOR2 player_xAxis[2];                                                    // gleiche wie bei box
        calcProj(player_xAxis, D3DXVECTOR2(1.0f, 0.0f), player_drawVertices);
        D3DXVECTOR2 player_yAxis[2];
        calcProj(player_yAxis, D3DXVECTOR2(0.0f, 1.0f), player_drawVertices);

        float box_xAxis_min = box_xAxis[0].x + box_xAxis[0].y;
        float box_xAxis_max = box_xAxis[1].x + box_xAxis[1].y;
        float box_yAxis_min = box_yAxis[0].x + box_yAxis[0].y;
        float box_yAxis_max = box_yAxis[1].x + box_yAxis[1].y;

        float player_xAxis_min = player_xAxis[0].x + player_xAxis[0].y;
        float player_xAxis_max = player_xAxis[1].x + player_xAxis[1].y;
        float player_yAxis_min = player_yAxis[0].x + player_yAxis[0].y;
        float player_yAxis_max = player_yAxis[1].x + player_yAxis[1].y;


kollision wird erkannt aba ich hab probleme den kleinsten vector zu berechnen.

danke

mfg JasonB

JasonB

Frischling

  • »JasonB« ist der Autor dieses Themas

Beiträge: 15

  • Private Nachricht senden

4

30.01.2011, 23:37

ich habe es geschafft den vector korrekt zu berechnen :D

hab es so gemacht:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

        if(player_xAxis_min > box_xAxis_max || player_xAxis_max < box_xAxis_min)
        {
            //
        }
        else
        {
            if(player_yAxis_min > box_yAxis_max || player_yAxis_max < box_yAxis_min)
            {
                //
            }
            else
            {
                float distanceX = 0.0f;
                float distanceY = 0.0f;

                if(player_xAxis_min < box_xAxis_min)
                {
                    distanceX = player_xAxis_max - box_xAxis_min;
                    distanceX = -distanceX;
                }
                else
                {
                    if(player_xAxis_max > box_xAxis_max)
                    {
                        distanceX = player_xAxis_min - box_xAxis_max;
                        distanceX = -distanceX;
                    }
                }

                if(player_yAxis_min < box_yAxis_min)
                {
                    distanceY = player_yAxis_max - box_yAxis_min;
                    distanceY = -distanceY;
                }
                else
                {
                    if(player_yAxis_max > box_yAxis_max)
                    {
                        distanceY = player_yAxis_min - box_yAxis_max;
                        distanceY = -distanceY;
                    }
                }

                float dx = distanceX;
                float dy = distanceY;

                if(distanceX < 0)
                {
                    dx = -distanceX;
                }
                if(distanceY < 0)
                {
                    dy = -distanceY;
                }

                if(dx < dy)
                {
                    if(dx == 0)
                    {
                        dx = 1;
                        dy = 0;
                    }
                    else
                    {
                        dx = 0;
                        dy = 1;
                    }
                }
                else
                {
                    if(dy == 0)
                    {
                        dy = 1;
                        dx = 0;
                    }
                    else
                    {
                        dy = 0;
                        dx = 1;
                    }

                }

                result = (dx > dy) ? D3DXVECTOR2(0.0f, 1.0f) * distanceY : D3DXVECTOR2(1.0f, 0.0f) * distanceX;
                player_position += result;
            }
        }


also 1. wird überprüft ob sich bei allen achsen (X, Y) die projizierten vectoren überschneiden, wenn ja
2. wird geguck wo der player sich bewindet - links oder rechts, oben oder unten vom box aus, und die größe der überlappungen(X, Y) wird berechnet
3. dann muss verglichen werden welche der überlappungen(X, Y) die kleinste is (ohne vorzeichen)
4. zum schluss wird die länge der übberlappung mit dem achsenvector multipliziert und zur position addiert.

habt ihr bessere möglichkeiten dies zu realisieren?

danke
-mfg JasonB

Werbeanzeige

Ähnliche Themen