Hypercell ein ] Hypercell aus ] Zeige Navigation ] Verstecke Navigation ]
c++.de  
   
Forentreff 2012     
Bücher-Shop mit Amazon (Buchkategorien)C++ : Referenzen zu C++ : C++ Builder : Visual C++ : C# : Java : Spieleprogrammierung : Systemprogrammierung Linux : Software-Entwicklung : .NET : Compilertechnik : Algorithmen & Datenstrukturen : Objektorientierung : Entwurfsmuster : UML : eXtreme Programming : Scrum : Projektmanagement : Software-Testing : Datenbanken : Tom DeMarco : Dilbert : User Friendly
C/C++ Forum :: Allgemeines zum Magazin ::  [Suchen Autor für:] Kollisionserkennung bei 3D Objekten  
Gehen Sie zu Seite Zurück  1, 2
  Zeige alle Beiträge auf einer Seite
Auf Beitrag antworten
Autor Nachricht
joomoo
Autor

Benutzerprofil
Anmeldungsdatum: 31.07.2004
Beiträge: 1520
Beitrag joomoo Autor 00:23:39 10.01.2007   Titel:              Zitieren

Ben04 schrieb:
Entweder Ebene und Gerade sind parallel oder sie schneiden sich. Wie man das am besten testet hängt davon ab wie du deine Gerade und deine Ebene Strukturen definiert hast.

Mich interessiert vor allem das Ausrechnen der Schnittposition. Meine Ebene ist halt eine rechteckige Oberfläche und für die Gerade ist es eher egal.

mfg.
Ben04
Autor

Benutzerprofil
Anmeldungsdatum: 10.10.2004
Beiträge: 1635
Beitrag Ben04 Autor 23:11:40 10.01.2007   Titel:              Zitieren

Eine Ebene kann mit einer Gleichung der Form:
§a_1 \cdot x + b_1 \cdot y + c_1 \cdot z = d_1 \equiv E_1§
dargestellt werden. Eine Gerade als Schnittpunkt von zwei nicht parallelen Ebenen:
§\left\{ \begin{array}{ll}
a_2 \cdot x + b_2 \cdot y + c_2 \cdot z = d_2 \equiv E_2\\
a_3 \cdot x + b_3 \cdot y + c_3 \cdot z = d_3 \equiv E_3
\end{array} \right§

Die Schnittstelle der Geraden und der Ebene ist die Lösung des Gleichungssystems:
§\left\{ \begin{array}{ll}
a_1 \cdot x + b_1 \cdot y + c_1 \cdot z = d_1\\
a_2 \cdot x + b_2 \cdot y + c_2 \cdot z = d_2\\
a_3 \cdot x + b_3 \cdot y + c_3 \cdot z = d_3
\end{array} \right§

Der schwierige Teil wird wohl sein die Gerade als Schnittpunkt von zwei Ebenen zu schreiben. Versuchen wir zuerst §a_2, b_2, c_2, a_3, b_3§ und §c_3§ zu bestimmen. Da §v = \[ \left( \begin{array}{ccc}a_2\\b_2\\c_2\end{array} \right)\]§ einen Vektor darstellt der rechtwinklig zur Ebene §E_2§ und man analoges über §E_3§ sagen kann, müssen wir also nur zwei Vektoren v und w suchen die rechtwinklig zur Geraden und nicht parallel unter sich sind.

Da wir unsere Gerade höchstwahrscheinlich als Gerade durch 2 Punkte definiert haben sollte es leicht sein einen parallelen Vektor zu finden (gibt ein Fachwort für so einen, kenne aber nur die französische Version und glaub kaum, dass die dir weiter hilft ;) ). Wir müssen nur die Differenz rechnen. Nennen wir diesen Vektor u.

Um die Rechtwinkligkeit auszudrücken benutzen wir das Skalarprodukt.
§u \cdot w = 0§
§u \cdot v = 0§
Da wir aber noch zusätzlich v nicht parallel zu w haben müssen und wir nur eine und nicht alle Lösungen brauchen würde ich es ein wenig strikter formulieren:
§u \cdot w = 0§
§u \times w = v§
w bestimmen wir indem wir drei Variablen einsetzen, das Skalarprodukt ausrechnen und dann irgendeinen möglichen Vektor w nehmen.

Jetzt müssen wir nur noch §d_2§ und §d_3§ bestimmen. Dies ist aber einfach da wir 2 Punkte der Geraden kennen §\[ \left( \begin{array}{ccc}x_1\\y_1\\z_1\end{array} \right)\]§ und §\[ \left( \begin{array}{ccc}x_2\\y_2\\z_2\end{array} \right)\]§
Nun sind uns aber auch die Koeffizienten bekannt also haben wir ein Gleichungssystem mit zwei Unbekannten:
§\left\{ \begin{array}{ll}
a_2 \cdot x_1 + b_2 \cdot y + c_2 \cdot z_1 = d_2\\
a_3 \cdot x_2 + b_3 \cdot y_2 + c_3 \cdot z_2 = d_3
\end{array} \right§


Wichtig ist zu beachten, dass es eine Gerade nicht Schnittpunkt von genau zwei Ebenen ist, sondern es gibt unendlich viele die sich in der gleichen Geraden schneiden.

Alternative Methode:
Man errechnet die Ebene die rechtwinklig zur gegebenen ist und die gegebene Gerade enthält. Man projektiert Ebene und Gerade darauf. Nun sind wir im 2 dimensionalen Raum und haben zwei Geraden. Wenn der Schnittpunkt gefunden ist muss man nur noch den Schritt zurück in den 3 dimensionalen Raum machen. Dazu muss man nur eine Bijektion zwischen Ebene und 2 dimensionalen Raum aufstellen.


Zuletzt bearbeitet von Ben04 am 23:22:25 10.01.2007, insgesamt 1-mal bearbeitet
TomasRiker
Mitglied

Benutzerprofil
Anmeldungsdatum: 26.09.2001
Beiträge: 2960
Beitrag TomasRiker Mitglied 23:54:06 13.01.2007   Titel:              Zitieren

Ben04 schrieb:
Eine Ebene kann mit einer Gleichung der Form:
§a_1 \cdot x + b_1 \cdot y + c_1 \cdot z = d_1 \equiv E_1§
dargestellt werden. Eine Gerade als Schnittpunkt von zwei nicht parallelen Ebenen: (...)

Viel zu umständlich!
Eine Gerade lässt sich viel einfacher als Startpunkt und Richtung schreiben.
Dann ist die Kollision zwischen Gerade und Ebene ein Witz (1 Gleichung mit 1 Variable).

_________________
http://www.spieleprogrammierer.de
Spiele, Tutorials & Infos zu meinen Büchern!
xochipilli
Unregistrierter




Beitrag xochipilli Unregistrierter 12:39:25 07.03.2007   Titel:   Kollissionserkennung: Punkt mit Richtungsvektor VS Dreieck            Zitieren

Hy@all

da ich selbst nicht die finger davon lassen konnte, wollte ich unbedingt mal anfangen eine 3D umgebung für ein computerspiel zu entwickeln, in dem man einen character in einer abgeschlossenen 3D Umgebung bewegen kann.

mit: OpenGL, Visual C++, Milkshape Models

ein teilproblem war die kollisionserkennung des characters mit der umgebung beim bewegen;

alle flächen werden als dreiecke, von denen ich die eckpunkskoordinaten (p1,p2,p3) habe, dargestellt.

die problemstellung in etwa:
wenn sich character von seiner aktuellen position in richtung seines blickvektors bewegt, tritt dann eine kollision mit der umgebung auf oder nicht.

lösungsansätze:
-> baryzentrische koordinaten: also schnittpunkt zwischen geraden und ebene errechnen; und wenn der schnittpunkt innerhalb des dreiecks liegt, ist die summe der baryzentrischen koordinaten des Schnittpunktes = 1.
dieser lösungsansatz lässt sich mit dem gewissen theoretischen know how auf fast alle kollisionsprobleme im beliebig-dimensionalen raum anwenden.
leider fehlt mir das theoretische know how über diese darstellung, dass ich es leider (noch) nicht geschafft habe diesen lösungsansatz zu implementieren.

-> basistransformation:
es wird eine neue verzerrte und verdrehte basis im 3D-Grundraum geschaffen, welche als ursprung die position des characters hat, und als basisrichtungen die richtungen von der charakterposition zu den eckpunkten des dreiecks.
aus den basisvektoren bildet man eine transformationsmatrix, mit welche wir beliebige vektoren als koordinaten unserer selbst geschaffenen basis darstellen können.
nun wird der blickvektor des charakters in diese basis transformiert, und mittels größenvergleich der einzelnen koordinaten festgestellt, ob der blickvektor innerhalb des dreiecks zeigt (sind alle koordinaten >= 0 dann ist dies der fall).

Hier nun der Code zur Kollisionserkennung mit Basistransformation:
als gegeben ist p1,p2,p3,mp, und mV anzusehen:
p1,p2,p3 ... Ortsvektoren der Eckpunkte des Dreiecks
mP ......... Position des Characters absolut
mV ......... Blickrichtungsvektor des Characters

noch eine kleine skizze von der situation:
http://www.hartl-auto.at/uni/raytracing2.jpg

C/C++ Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
tVector3 p1q = p1-mP; p1q = p1q / p1q.abs(); // Seitenkante des Dreiecks
tVector3 p2q = p2-mP; p2q = p2q / p2q.abs(); // Seitenkante des Dreiecks
tVector3 p3q = p3-mP; p3q = p3q / p3q.abs(); // Seitenkante des Dreiecks
tMatrix33 tMq = tMatrix33(p1q,p2q,p3q); // Transformationsmatrix von schiefer in normale Basis
tMq = tMq.inverse(); // Transformationsmatrix von normale in schiefe basis
tVector3 tRq = tMq * mV;
if( (tRq.x>=0) && (tRq.y>=0) && (tRq.z>=0) )
    { //Schnittpunkt innerhalb  des dreiecks
    tVector3 nT = (p1-p2)%(p1-p3);     nT=nT/nT.abs();//Normalvektor auf fläche
    float dist = (nT&(mP-p1));
    if(dist<0.3f && dist > -0.3f) // wenn abstand kleiner als 3
    {/*KOLLISION*/}
    }
C/C++ Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
tVector3 p1q = p1-mP; p1q = p1q / p1q.abs(); // Seitenkante des Dreiecks
tVector3 p2q = p2-mP; p2q = p2q / p2q.abs(); // Seitenkante des Dreiecks
tVector3 p3q = p3-mP; p3q = p3q / p3q.abs(); // Seitenkante des Dreiecks
tMatrix33 tMq = tMatrix33(p1q,p2q,p3q); // Transformationsmatrix von schiefer in normale Basis
tMq = tMq.inverse(); // Transformationsmatrix von normale in schiefe basis
tVector3 tRq = tMq * mV;
if( (tRq.x>=0) && (tRq.y>=0) && (tRq.z>=0) )
{ //Schnittpunkt innerhalb des dreiecks
tVector3 nT = (p1-p2)%(p1-p3); nT=nT/nT.abs();//Normalvektor auf fläche
float dist = (nT&(mP-p1));
if(dist<0.3f && dist > -0.3f) // wenn abstand kleiner als 3
{/*KOLLISION*/}
}
C/C++ Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
tVector3 p1q = p1-mP; p1q = p1q / p1q.abs(); // Seitenkante des Dreiecks
tVector3 p2q = p2-mP; p2q = p2q / p2q.abs(); // Seitenkante des Dreiecks
tVector3 p3q = p3-mP; p3q = p3q / p3q.abs(); // Seitenkante des Dreiecks
tMatrix33 tMq = tMatrix33(p1q,p2q,p3q); // Transformationsmatrix von schiefer in normale Basis
tMq = tMq.inverse(); // Transformationsmatrix von normale in schiefe basis
tVector3 tRq = tMq * mV;
if( (tRq.x>=0) && (tRq.y>=0) && (tRq.z>=0) )
    { //Schnittpunkt innerhalb  des dreiecks
    tVector3 nT = (p1-p2)%(p1-p3);     nT=nT/nT.abs();//Normalvektor auf fläche
    float dist = (nT&(mP-p1));
    if(dist<0.3f && dist > -0.3f) // wenn abstand kleiner als 3
    {/*KOLLISION*/}
    }


zur info noch der aufbau der von mir verwendeten stuktur für voktoren und matrizen:
C/C++ Code:
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
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
typedef struct tVector3               
{           
    tVector3() {}   
    tVector3 (float new_x, float new_y, float new_z)
    {x = new_x; y = new_y; z = new_z;}
   
    tVector3 operator+(tVector3 vVector)
    {return tVector3(vVector.x+x, vVector.y+y, vVector.z+z);}
   
    tVector3 operator-(tVector3 vVector)
    {return tVector3(x-vVector.x, y-vVector.y, z-vVector.z);}
   
    tVector3 operator*(float number)   
    {return tVector3(x*number, y*number, z*number);}
   
    tVector3 operator/(float number)
    {return tVector3(x/number, y/number, z/number);}
   
    tVector3 operator%(tVector3 vVector)//CROSS PRODUKT
    {return tVector3(y*vVector.z-z*vVector.y,z*vVector.x-x*vVector.z, x*vVector.y-y*vVector.x);}

    float operator&(tVector3 vVector)//DOT PRODUKT
    {return x*(vVector.x) + y*(vVector.y) + z*(vVector.z);}

    float abs()
    {return float(sqrt(x*x+y*y+z*z));}
    float abs2()
    {return (x*x+y*y+z*z);}

    tVector3 normalize()
        {
        float a=abs();
        x=x/a; y=y/a; z=z/a;
        return tVector3(x,y,z);
        }

    float x, y, z;                       
}tVector3;

typedef struct tMatrix33               
{           
    tMatrix33() {}   

    tMatrix33 (float new_x1, float new_y1, float new_z1,
                float new_x2, float new_y2, float new_z2,
                float new_x3, float new_y3, float new_z3)
        {
        x1 = new_x1; y1 = new_y1; z1 = new_z1;
        x2 = new_x2; y2 = new_y2; z2 = new_z2;
        x3 = new_x3; y3 = new_y3; z3 = new_z3;
        }

    tMatrix33 (tVector3 v1, tVector3 v2, tVector3 v3)
        {
        x1 = v1.x; y1 = v1.y; z1 = v1.z;
        x2 = v2.x; y2 = v2.y; z2 = v2.z;
        x3 = v3.x; y3 = v3.y; z3 = v3.z;
        }
   
    tVector3 operator*(tVector3 vec)   
        {
        return tVector3(    x1*vec.x + x2*vec.y + x3*vec.z,
                            y1*vec.x + y2*vec.y + y3*vec.z,
                            z1*vec.x + z2*vec.y + z3*vec.z);
        }
    float det()
        {
        return (x1*y2*z3) + (x2*y3*z1) + (y1*z2*x3) - (z1*y2*x3) - (y1*x2*z3) - (z2*y3*x1);
        }

    tMatrix33 inverse()
        {
        float d = det();
        return tMatrix33((y2*z3-z2*y3)/d , (y3*z1-z3*y1)/d, (y1*z2-z1*y2)/d,
                        (x3*z2-z3*x2)/d, (x1*z3-z1*x3)/d, (x2*z1-z2*x1)/d,
                        (x2*y3-y2*x3)/d, (x3*y1-y3*x1)/d, (x1*y2-y1*x2)/d);
        }
       
    float x1, x2, x3; //
    float y1, y2, y3; // MATRIX LOOKS LIKE THIS
    float z1, z2, z3; //               
   
}tMatrix333;
C/C++ Code:
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
typedef struct tVector3
{
tVector3() {}
tVector3 (float new_x, float new_y, float new_z)
{x = new_x; y = new_y; z = new_z;}

tVector3 operator+(tVector3 vVector)
{return tVector3(vVector.x+x, vVector.y+y, vVector.z+z);}

tVector3 operator-(tVector3 vVector)
{return tVector3(x-vVector.x, y-vVector.y, z-vVector.z);}

tVector3 operator*(float number)
{return tVector3(x*number, y*number, z*number);}

tVector3 operator/(float number)
{return tVector3(x/number, y/number, z/number);}

tVector3 operator%(tVector3 vVector)//CROSS PRODUKT
{return tVector3(y*vVector.z-z*vVector.y,z*vVector.x-x*vVector.z, x*vVector.y-y*vVector.x);}

float operator&(tVector3 vVector)//DOT PRODUKT
{return x*(vVector.x) + y*(vVector.y) + z*(vVector.z);}

float abs()
{return float(sqrt(x*x+y*y+z*z));}
float abs2()
{return (x*x+y*y+z*z);}

tVector3 normalize()
{
float a=abs();
x=x/a; y=y/a; z=z/a;
return tVector3(x,y,z);
}

float x, y, z;
}tVector3;

typedef struct tMatrix33
{
tMatrix33() {}

tMatrix33 (float new_x1, float new_y1, float new_z1,
float new_x2, float new_y2, float new_z2,
float new_x3, float new_y3, float new_z3)
{
x1 = new_x1; y1 = new_y1; z1 = new_z1;
x2 = new_x2; y2 = new_y2; z2 = new_z2;
x3 = new_x3; y3 = new_y3; z3 = new_z3;
}

tMatrix33 (tVector3 v1, tVector3 v2, tVector3 v3)
{
x1 = v1.x; y1 = v1.y; z1 = v1.z;
x2 = v2.x; y2 = v2.y; z2 = v2.z;
x3 = v3.x; y3 = v3.y; z3 = v3.z;
}

tVector3 operator*(tVector3 vec)
{
return tVector3( x1*vec.x + x2*vec.y + x3*vec.z,
y1*vec.x + y2*vec.y + y3*vec.z,
z1*vec.x + z2*vec.y + z3*vec.z);
}
float det()
{
return (x1*y2*z3) + (x2*y3*z1) + (y1*z2*x3) - (z1*y2*x3) - (y1*x2*z3) - (z2*y3*x1);
}

tMatrix33 inverse()
{
float d = det();
return tMatrix33((y2*z3-z2*y3)/d , (y3*z1-z3*y1)/d, (y1*z2-z1*y2)/d,
(x3*z2-z3*x2)/d, (x1*z3-z1*x3)/d, (x2*z1-z2*x1)/d,
(x2*y3-y2*x3)/d, (x3*y1-y3*x1)/d, (x1*y2-y1*x2)/d);
}

float x1, x2, x3; //
float y1, y2, y3; // MATRIX LOOKS LIKE THIS
float z1, z2, z3; //

}tMatrix333;
C/C++ Code:
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
typedef struct tVector3               
{           
    tVector3() {}   
    tVector3 (float new_x, float new_y, float new_z)
    {x = new_x; y = new_y; z = new_z;}
   
    tVector3 operator+(tVector3 vVector)
    {return tVector3(vVector.x+x, vVector.y+y, vVector.z+z);}
   
    tVector3 operator-(tVector3 vVector)
    {return tVector3(x-vVector.x, y-vVector.y, z-vVector.z);}
   
    tVector3 operator*(float number)   
    {return tVector3(x*number, y*number, z*number);}
   
    tVector3 operator/(float number)
    {return tVector3(x/number, y/number, z/number);}
   
    tVector3 operator%(tVector3 vVector)//CROSS PRODUKT
    {return tVector3(y*vVector.z-z*vVector.y,z*vVector.x-x*vVector.z, x*vVector.y-y*vVector.x);}

    float operator&(tVector3 vVector)//DOT PRODUKT
    {return x*(vVector.x) + y*(vVector.y) + z*(vVector.z);}

    float abs()
    {return float(sqrt(x*x+y*y+z*z));}
    float abs2()
    {return (x*x+y*y+z*z);}

    tVector3 normalize()
        {
        float a=abs();
        x=x/a; y=y/a; z=z/a;
        return tVector3(x,y,z);
        }

    float x, y, z;                       
}tVector3;

typedef struct tMatrix33               
{           
    tMatrix33() {}   

    tMatrix33 (float new_x1, float new_y1, float new_z1,
                float new_x2, float new_y2, float new_z2,
                float new_x3, float new_y3, float new_z3)
        {
        x1 = new_x1; y1 = new_y1; z1 = new_z1;
        x2 = new_x2; y2 = new_y2; z2 = new_z2;
        x3 = new_x3; y3 = new_y3; z3 = new_z3;
        }

    tMatrix33 (tVector3 v1, tVector3 v2, tVector3 v3)
        {
        x1 = v1.x; y1 = v1.y; z1 = v1.z;
        x2 = v2.x; y2 = v2.y; z2 = v2.z;
        x3 = v3.x; y3 = v3.y; z3 = v3.z;
        }
   
    tVector3 operator*(tVector3 vec)   
        {
        return tVector3(    x1*vec.x + x2*vec.y + x3*vec.z,
                            y1*vec.x + y2*vec.y + y3*vec.z,
                            z1*vec.x + z2*vec.y + z3*vec.z);
        }
    float det()
        {
        return (x1*y2*z3) + (x2*y3*z1) + (y1*z2*x3) - (z1*y2*x3) - (y1*x2*z3) - (z2*y3*x1);
        }

    tMatrix33 inverse()
        {
        float d = det();
        return tMatrix33((y2*z3-z2*y3)/d , (y3*z1-z3*y1)/d, (y1*z2-z1*y2)/d,
                        (x3*z2-z3*x2)/d, (x1*z3-z1*x3)/d, (x2*z1-z2*x1)/d,
                        (x2*y3-y2*x3)/d, (x3*y1-y3*x1)/d, (x1*y2-y1*x2)/d);
        }
       
    float x1, x2, x3; //
    float y1, y2, y3; // MATRIX LOOKS LIKE THIS
    float z1, z2, z3; //               
   
}tMatrix333;


ich hoffe ich konnte damit vielleicht irgendwem helfen, der so wie ich gestern, auf der suche nach einfachen kollisionserkennungsmethoden für gerade/dreieck ist...

ich bin leider sehr ungeübt in c++, und habe auch kaum erfahrung damit, deshalb entschuldige ich mich hier gleich mal für das was ich mit meinen code so manchem leser antue!!

mfg HH

p.s.: habe auch noch einen ähnlichen algorithmus zur bestimmung des maximalen abstandes eines raumpunktes entlang eines richtungsvektors bis zur kollision!
(diesen hab ich dann für die kamerapositionierung verwendet)....
wenn wer interessiert sein sollte.....
Kenner des 5D
Unregistrierter




Beitrag Kenner des 5D Unregistrierter 21:24:29 14.03.2008   Titel:              Zitieren

Ben04 schrieb:

Entweder Ebene und Gerade sind parallel oder sie schneiden sich.
Falsch!
Ben04
Autor

Benutzerprofil
Anmeldungsdatum: 10.10.2004
Beiträge: 1635
Beitrag Ben04 Autor 00:41:45 15.03.2008   Titel:              Zitieren

Kenner des 5D schrieb:
Ben04 schrieb:

Entweder Ebene und Gerade sind parallel oder sie schneiden sich.
Falsch!

Lies doch mal die Überschrift:"...bei 3D Objekten"
C/C++ Forum :: Allgemeines zum Magazin ::  [Suchen Autor für:] Kollisionserkennung bei 3D Objekten  
Gehen Sie zu Seite Zurück  1, 2
Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.de ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info, www.c-sar.de, www.c-plusplus.net und www.baeckmann.de enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.