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!

TriBase Engine erweitern

  • 1
  • 2

Werbeanzeige

jube

Frischling

  • »jube« ist der Autor dieses Themas

Beiträge: 36

Beruf: Schüler

  • Private Nachricht senden

1

29.11.2003, 13:09

TriBase Engine erweitern

Hallo,
ich bin dabei mein erstes Spiel mit der Tb Engine zu programmieren und hätte danach vor einen ganz einfachen Ego shooter zu schreiben(einfache Grafik, nur so Klötze oder so)mit der Engine. Dafür müsste ich sie ja erst erweitern. Ist das zu aufwändig? Weiß irgendjemand vielleicht ein Tutorial
in dem beschrieben wird wie man so was bewerkstelligen kann? Danke schon mal. Bitte ins "Spieleprogrammierung"-Forum verschieben. Habs aus Versehen falsch gepostet. Sorry
Ciao,
Julian

Patrick

Alter Hase

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

2

29.11.2003, 13:31

Hi,

hm nee du solltest so ne Kubusklasse erstellen und so, ich denke dafür würdest du zwar noch einiges erweitern aber sonst ok.

--> p.s.: nein das geht ins "Das Buch"-Forum ;)
[ German Game Dev | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]

jube

Frischling

  • »jube« ist der Autor dieses Themas

Beiträge: 36

Beruf: Schüler

  • Private Nachricht senden

3

29.11.2003, 20:50

Was ist eine Kubusklasse? Gibts vielleicht irgendwo ein Tut über sowas?
Danke schon mal.
Julian

Patrick

Alter Hase

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

4

29.11.2003, 21:24

Ne Kubusklasse? Hm scheine ein neues Wort erfunden zu haben ;D naja egal das prinzip ist easy!

Quellcode

 
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

CCube : public CBoundingBox
{
public:
    CCube (void) : m_type (0x000000), m_collidable (true), m_size (2) {}

    void render(void)
    {
        switch (this->m_type)
        {
        case 0x000000:
            {
                // Rendere normalen Kubus
            } break;
        case 0x000001:
            {
                // Rendere normalen Kubus mit leichten Deformationen
            } break;
        case 0x000002:
            {
                // Rendere normalen Kubus mit starken Deformationen
            } break;
        default : break;
        }
    }

private:
    int m_type;
}


Da du ja alles per Klötze (Kuben) machen willst, würde das so recht gut funktionieren wie in meinem Codebeispiel. Für die Kollision reicht bei diesem Prinzip einfache AABBs (Achsen Ausgerichtete Bounding Box). Hier wird die CCube von der CBoundingBox abgeleitet.

Nur das Aussehen sieht anders aus (m_type) aber die Kollisionsabfrage bleibt die selbe. Nach diesem Prinzip könnte man jedes Game auf Klötzchenebene Realisieren.

Recht easy ;)
[ German Game Dev | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]

Stefan

Alter Hase

Beiträge: 668

Wohnort: Innsbruck

  • Private Nachricht senden

5

29.11.2003, 22:34

@Patrick
hm, gute Idee alles auf Würfel aufzubauen, nur versehe ich nicht ganz, wie ich die Kollisionsabfrage mit AABBs machen soll! Gibts dazu vielleicht irgendwo ein Tuturial??
thx

Patrick

Alter Hase

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

6

29.11.2003, 23:47

Hi,

ja, das Tutorial braucht leider noch etwas :) Aber hier die Klasse für BoundingBoxen + Sample

Quellcode

 
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

// Datei:           CBoundingBox.h
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        20.11.03
// Änderungen:     20.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Struktur für BoundingBoxen

#ifndef _CBOUNDINGBOX_H_
#define _CBOUNDINGBOX_H_

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "..\\math\\CVector3.h"
#include "..\\core\\CVideo.h"

// D E F I N I T I O N E N //////////////////////////////////////////////////////////
    // Noch keine

// S T R U K T U R E N //////////////////////////////////////////////////////////////
class CBoundingBox
{
public:
        // Constructor
    CBoundingBox            (void)  :   m_Collidable (true) {}
        // Destructor
    virtual ~CBoundingBox   (void)                          {}

        // Diverse set-Funktionen.
    void            setCollidable       (bool value)    { this->m_Collidable = value; }
    void            setBBPosition       (CVector3<float>);
    void            setBBMin            (CVector3<float>);
    void            setBBMax            (CVector3<float>);

        // Diverse get-Funktionen
    CVector3<float> getBBPosition       (void);
    CVector3<float> getBBMin            (void);
    CVector3<float> getBBMax            (void);

        // Kann die BoundingBox mit irgendetwas Kollidieren?
    inline bool     isCollidable        (void)  { return (this->m_Collidable); }

        // Funktion zum rendern der BoundingBox.
    void            renderBoundingBox   (void);

        // Kollisionsfunktionen für BB mit BB und BB mit Point.
    bool            collidesWith        (CBoundingBox *object);
    bool            collidesWith        (CVector3<float> &point);

private:
        // Darf die BoundingBox später mit irgendetwas kollidieren?
    bool            m_Collidable;

        // Daten über die BoundingBox.
    CVector3<float> m_Position;
    CVector3<float> m_Min;
    CVector3<float> m_Max;
};

#endif

Quellcode

 
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

// Datei:           CBoundingBox.cpp
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        20.11.03
// Änderungen:     20.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Struktur für BoundingBoxen

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "CBoundingBox.h"

// F U N K T I O N E N //////////////////////////////////////////////////////////////

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum setzen einer einen Position.
//
// [in] position: Die neue Position für die Box.
// /////////////////////////////////////////////////
void CBoundingBox::setBBPosition (CVector3<float> position)
{
    this->m_Position = position;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum setzen eines neuen Minimums.
//
// [in] value: Das neue Minimum für die Box.
// /////////////////////////////////////////////////
void CBoundingBox::setBBMin (CVector3<float> value)
{
    this->m_Min = value;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum setzen eines neuen Maximums.
//
// [in] value: Das neue Maximum für die Box.
// /////////////////////////////////////////////////
void CBoundingBox::setBBMax (CVector3<float> value)
{
    this->m_Max = value;
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum abfragen der Box-Position.
//
// [ret] Die Position der Box.
// /////////////////////////////////////////////////
CVector3<float> CBoundingBox::getBBPosition (void)
{
    return (this->m_Position);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum abfragen des Minimums der Box.
//
// [ret] Das Minimum der Box.
// /////////////////////////////////////////////////
CVector3<float> CBoundingBox::getBBMin (void)
{
    return (this->m_Min);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum abfragen des Maximums der Box.
//
// [ret] Das Maximum der Box.
// /////////////////////////////////////////////////
CVector3<float> CBoundingBox::getBBMax (void)
{
    return (this->m_Max);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion für Kollision mit einem Punkt.
//
// [in] point: Ein Punkt im 3D Raum.
//
// [ret] true wenn kollision statt gefunden hat und
//       false wenn nicht.
// /////////////////////////////////////////////////
bool CBoundingBox::collidesWith (CVector3<float> &point)
{
        // Ist überhaupt eine Kollision erwünscht?
    if (!this->m_Collidable)
        return (false);

        // X Seiten vergleichen
    if(this->m_Max.getX() + this->m_Position.getX() <= point.getX()) 
        return (false);
    if(this->m_Min.getX() + this->m_Position.getX() >= point.getX()) 
        return (false);

        // Y Seiten vergleichen
    if(this->m_Max.getY() + this->m_Position.getY() <= point.getY()) 
        return (false);
    if(this->m_Min.getY() + this->m_Position.getY() >= point.getY()) 
        return (false);

        // Z Seiten vergleichen
    if(this->m_Max.getZ() + this->m_Position.getZ() <= point.getZ()) 
        return (false);
    if(this->m_Min.getZ() + this->m_Position.getZ() >= point.getZ()) 
        return (false);

        // Wenn wir bis hier kommen, findet eine Kollision statt.
    return (true);  
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion für Kollision mit einer anderen Box.
//
// [in] object: Die Box mit der kollidiert werden soll.
//
// [ret] true wenn kollision statt gefunden hat und
//       false wenn nicht.
// /////////////////////////////////////////////////
bool CBoundingBox::collidesWith (CBoundingBox *object) 
{
        // Ist überhaupt eine Kollision erwünscht?
    if (!this->m_Collidable || !object->isCollidable())
        return (false);

        // X Seiten vergleichen
    if (this->m_Max.getX() + this->m_Position.getX() < object->getBBMin().getX() + object->getBBPosition().getX() || object->getBBMax().getX() + object->getBBPosition().getX() < this->m_Min.getX() + this->m_Position.getX()) 
        return (false);

        // Y Seiten vergleichen
    if (this->m_Max.getY() + this->m_Position.getY() < object->getBBMin().getY() + object->getBBPosition().getY() || object->getBBMax().getY() + object->getBBPosition().getY() < this->m_Min.getY() + this->m_Position.getY()) 
        return (false);

        // Z Seiten vergleichen
    if (this->m_Max.getZ() + this->m_Position.getZ() < object->getBBMin().getZ() + object->getBBPosition().getZ() || object->getBBMax().getZ() + object->getBBPosition().getZ() < this->m_Min.getZ() + this->m_Position.getZ()) 
        return (false);

        // Wenn wir bis hier kommen, findet eine Kollision statt.
    return (true);
}

// /////////////////////////////////////////////////
// PUBLIC 
//
// Funktion zum rendern der BoundingBox.
// /////////////////////////////////////////////////
void CBoundingBox::renderBoundingBox (void)
{
        // BoundingBoxen werden in der Regel immer ohne Textur gerendert
    glBindTexture(GL_TEXTURE_2D, NULL);

        // Und Rendern der linien
    glBegin(GL_LINE_LOOP);
        glVertex3f (this->m_Min.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
        glVertex3f (this->m_Max.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
        glVertex3f (this->m_Max.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
        glVertex3f (this->m_Min.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
    glEnd();

    glBegin(GL_LINE_LOOP);
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
    glEnd();

    glBegin(GL_LINES);
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Min.getZ() + this->m_Position.getZ());
   glEnd();

   glBegin(GL_LINES);
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Max.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Min.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
       glVertex3f(this->m_Min.getX() + this->m_Position.getX(), this->m_Max.getY() + this->m_Position.getY(), this->m_Max.getZ() + this->m_Position.getZ());
    glEnd();
}


Beispiel

Quellcode

 
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

// Datei:           Sample.cpp
// //////////////////////////////////////////////////////////////////////////////////
// Autor:           Patrick Ullmann                             © Xarent Interactive
// Erstellt:        19.11.03
// Änderungen:     19.11.03    (Patrick)   Datei erstellt
// //////////////////////////////////////////////////////////////////////////////////
// Beschreibung:    Sample Datei

// I N C L U D E S //////////////////////////////////////////////////////////////////
#include "sample.h"
#include "objects\\CBoundingBox.h"

// G L O B A L E S //////////////////////////////////////////////////////////////////
CFont g_Font;
CBoundingBox Box1;
CBoundingBox Box2;

// F U N K T I O N E N //////////////////////////////////////////////////////////////

// /////////////////////////////////////////////////
// GLOBAL 
//
// Funktion zum laden des Samples.
// /////////////////////////////////////////////////
void SampleLoad (void)
{
    g_Font.init ("data\\gfx\\font.bmp");
    TEXTUREMANAGER->loadTexture ("data\\gfx\\background.bmp");

    Box1.setBBMin (CVector3<float> (-1,-1,-1));
    Box1.setBBMax (CVector3<float> (1,1,1));
    Box1.setBBPosition (CVector3<float> (0,0,-10));

    Box2.setBBMin (CVector3<float> (-1,-1,-1));
    Box2.setBBMax (CVector3<float> (1,1,1));
    Box2.setBBPosition (CVector3<float> (0,0,-10));
}

// /////////////////////////////////////////////////
// GLOBAL 
//
// Funktion zum abspielen des Samples.
// /////////////////////////////////////////////////
void SampleRun  (void)
{
        // Backbuffer mit Schwarz leeren.
    VIDEO->clear (0.0f, 0.0f, 0.0f);

        // Alles resetten
    glLoadIdentity (); 


        // Statische Variable für die Bewegung
    static float move = 3.0f;

        // Input abfragen
    if(KEYBOARD->isKeyDown (SDLK_LEFT))
        move -= 0.25f;

    if(KEYBOARD->isKeyDown (SDLK_RIGHT))
        move += 0.25f;

        // Neue Position setzen.
    Box1.setBBPosition (CVector3<float> (-move,0,-10));
    Box2.setBBPosition (CVector3<float> (move,0,-10));

        // Teste ob eine Kollision statt gefunden hat.
    if(Box1.collidesWith (CVector3<float> (0,0,-10)))
    {
            // Wenn ja, roten Text rendern und die Boxen auch in rot.
        glColor3f (1.0f, 0.0f, 0.0f);
        g_Font.print (10, 10, "Collision!!!", true);
    }

        // Boxen rendern
    Box1.renderBoundingBox ();
    Box2.renderBoundingBox ();

        //Normalen Text rendern:
    glColor3f (1.0f, 1.0f, 1.0f);
    g_Font.print (10, 30, "Tutorial 3: BoundingBox     Use the LEFT and the RIGHT key to move the BBs.", true);

        // Und auf den Monitor hauen
    VIDEO->present ();
}



Ich hoffe du kannst damit etwas anfangen :)

Gute Nacht,
Patrick :)
[ German Game Dev | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

7

30.11.2003, 00:45

Sehe ich das richtig, dass die Box-Kollision einen Fall wie den folgenden nicht erkennt:

Quellcode

 
1
2
3
4
5
6
7
8

   _____
   |   |
 ___|___|___
|  |   |  |
|  |   |  |
|__|___|__|
   |   |
   |___|
David Scherfgens Website | Konzentrationstest Polizei

Patrick

Alter Hase

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

8

30.11.2003, 00:48

Stimmt, und das zurecht, da es in dem Tut diesen Fall niemals geben wird ;) Es wird eine temp koordiante gesetzt, dann wird getestet ob eine Seite dieser Koordinate in die BB eintritt, wenn ja, wird die Koordiante an die BB mit der sie kollidiert angepasst :) Drum hab ich auf dieses "extra" verzichtet :)
[ German Game Dev | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]

ghostie

Alter Hase

Beiträge: 382

  • Private Nachricht senden

9

30.11.2003, 12:49

Das kann aber schief geht und ist nicht gerade gut Überlegt besonders für ein Gameprogger.

Ach ja, momentan Spiel ich ein bisschen mit SDL wenn mich DX mal wieder nervt. Is schön einfach dieses SDL :D

Patrick

Alter Hase

Beiträge: 1 264

Wohnort: Düren

Beruf: Fachinformatiker für Anwendungsentwicklung

  • Private Nachricht senden

10

30.11.2003, 12:51

dieses feature hab ich heute nacht um 04:00 eingebaut :) Jetzt funzt die kollisionsabfrage auch richtig, auch wenn dieser Event nach meiner meinung nicht eintreten kann. aber egal :)

@Ghostie:
Ach du spielst mit SDL? ;D was kommt als nächstes? OpenGL und OpenAL? ;D;D;D;D
[ German Game Dev | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]

Werbeanzeige

  • 1
  • 2