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!

glDrawElements VBO texturieren

  • 1
  • 2

Werbeanzeige

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

1

09.02.2011, 15:57

glDrawElements VBO texturieren

Hi, mal wieder :D

ich bekomms gerade nicht hin Boxen mit VBOs zu texturieren. Die Klasse sieht so aus:

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

        GLuint m_vBuffer, m_iBuffer, m_tBuffer, m_texture;
        vector<float> m_blocks;
        vector<unsigned int> m_share;
        vector<float> m_texCoords;
        float m_blockSize;
        unsigned int m_size;
        bool m_create;

// paar Methoden...

                void add(float x, float y, float z){
            if(m_create){
                // Berechnung Vertex und Indices, ablegen in m_blocks/m_share

                m_texCoords.push_back(0.0);
                m_texCoords.push_back(1.0);
            }
            else{
                // direkt in VBO (kommt später)
            }

            m_size++;
        }

        void createData(){
            m_create = false;

            // Koordinaten
            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer);
            glBufferData(GL_ARRAY_BUFFER, m_size*24*sizeof(float), &m_blocks[0], GL_STATIC_DRAW); 

            // Koordinaten teilen
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iBuffer);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_size*36*sizeof(unsigned int), &m_share[0], GL_STATIC_DRAW); 

            // Texturkoordinaten
            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer);
            glBufferData(GL_ARRAY_BUFFER, m_size*2*sizeof(float), &m_texCoords[0], GL_STATIC_DRAW); 
        }

        void draw(){
            // VBOs updaten
            if(m_create){
                createData();
            }

            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iBuffer);
            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer);
            
            glVertexPointer(3, GL_FLOAT, 0, 0);
            glTexCoordPointer(2, GL_FLOAT, 0, 0);
            
            glEnableClientState(GL_VERTEX_ARRAY);
            glDrawElements(GL_TRIANGLES, m_share.size(), GL_UNSIGNED_INT, 0);
            glDisableClientState(GL_VERTEX_ARRAY);
        }


Was mache ich falsch? Wenn ich die Textur (ist nur eine [Texture Atlas]) rausnehme werden mir alle Boxen angezeigt, mit nur ein grünes Dreieck (grün ist auch in der Grafik). Kann man überhaupt einfach 2 Dreiecke "übertexturieren" oder brauch das mehr?
So sieht das laden der Grafik aus:

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

void loadTexture(char* path){ 
    TargaImage texture;
    
    if(!texture.load(path)){
        cout<<"Fehler beim laden der Textur"<<endl;    
    }
     
    glBindTexture(GL_TEXTURE_2D, textures[texturesIndex]);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D,
                 0,                      
                 GL_RGB8,          
                 texture.getWidth(),          
                 texture.getHeight(), 
                 0,       
                 GL_RGB,           
                 GL_UNSIGNED_BYTE,  
                 texture.getImageData());
                 
    texturesIndex++;
}
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

2

09.02.2011, 16:06

C-/C++-Quelltext

 
1
2
3
4
5
6

            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iBuffer);
            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer);
            
            glVertexPointer(3, GL_FLOAT, 0, 0);
            glTexCoordPointer(2, GL_FLOAT, 0, 0);

Überleg mal was du da machst: Du bindest erst das eine VBO, dann bindest du das andre VBO und dann setzt du glVertexPointer() und glTexCoordPointer()...beides auf das letzte VBO...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

3

09.02.2011, 17:19

Öhm, ups... stimmt, naja Anfänger halt :) aber ich bekomm bestimmt bald nochmal Probleme dazu ^^. Da lohnt der Thread vielleicht noch.

[EDIT]

Ja sag ich doch...
Wie kann ich denn jetzt über 2 Dreiecke texturieren? Muss ich dazu 2, 3 oder 4 Koordinaten angeben? Die Ausgabe ist jetzt richtig, allerdings sind alle Blöcke grün...
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

4

09.02.2011, 17:57

Also die Textur wird definitiv draufgezeichnet, nur wie muss ich die Koordinaten angeben?

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
88
89
90
91
92
93
94
95
96
97
98
99

                                float texCoord[] = {1.0, 0.0};

                                m_blocks.push_back(x*m_blockSize);
                m_blocks.push_back(y*m_blockSize);
                m_blocks.push_back(z*m_blockSize);

                m_blocks.push_back(x*m_blockSize+m_blockSize);
                m_blocks.push_back(y*m_blockSize);
                m_blocks.push_back(z*m_blockSize);

                m_blocks.push_back(x*m_blockSize+m_blockSize);
                m_blocks.push_back(y*m_blockSize);
                m_blocks.push_back(z*m_blockSize+m_blockSize);

                m_blocks.push_back(x*m_blockSize);
                m_blocks.push_back(y*m_blockSize);
                m_blocks.push_back(z*m_blockSize+m_blockSize);

                m_blocks.push_back(x*m_blockSize);
                m_blocks.push_back(y*m_blockSize+m_blockSize);
                m_blocks.push_back(z*m_blockSize);

                m_blocks.push_back(x*m_blockSize+m_blockSize);
                m_blocks.push_back(y*m_blockSize+m_blockSize);
                m_blocks.push_back(z*m_blockSize);

                m_blocks.push_back(x*m_blockSize+m_blockSize);
                m_blocks.push_back(y*m_blockSize+m_blockSize);
                m_blocks.push_back(z*m_blockSize+m_blockSize);

                m_blocks.push_back(x*m_blockSize);
                m_blocks.push_back(y*m_blockSize+m_blockSize);
                m_blocks.push_back(z*m_blockSize+m_blockSize);

                m_share.push_back(0+m_size*8); // Boden
                m_share.push_back(1+m_size*8);
                m_share.push_back(3+m_size*8);

                m_share.push_back(1+m_size*8);
                m_share.push_back(2+m_size*8);
                m_share.push_back(3+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);

                m_share.push_back(5+m_size*8); // Deckel
                m_share.push_back(6+m_size*8);
                m_share.push_back(7+m_size*8);

                m_share.push_back(4+m_size*8);
                m_share.push_back(5+m_size*8);
                m_share.push_back(7+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);

                m_share.push_back(0+m_size*8); // Wand 1
                m_share.push_back(1+m_size*8);
                m_share.push_back(4+m_size*8);

                m_share.push_back(1+m_size*8);
                m_share.push_back(5+m_size*8);
                m_share.push_back(4+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);

                m_share.push_back(1+m_size*8); // Wand 2
                m_share.push_back(2+m_size*8);
                m_share.push_back(5+m_size*8);

                m_share.push_back(2+m_size*8);
                m_share.push_back(6+m_size*8);
                m_share.push_back(5+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);

                m_share.push_back(2+m_size*8); // Wand 3
                m_share.push_back(3+m_size*8);
                m_share.push_back(6+m_size*8);

                m_share.push_back(3+m_size*8);
                m_share.push_back(7+m_size*8);
                m_share.push_back(6+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);

                m_share.push_back(3+m_size*8); // Wand 4
                m_share.push_back(0+m_size*8);
                m_share.push_back(7+m_size*8);

                m_share.push_back(0+m_size*8);
                m_share.push_back(4+m_size*8);
                m_share.push_back(7+m_size*8);

                m_texCoords.push_back(texCoord[0]);
                m_texCoords.push_back(texCoord[1]);



(Link)


Wie man hier sieht wird die Textur über den gesamten Würfel gezogen, soll sie aber nicht. Sie soll 6 mal jeweils auf eine Seite projeziert werden.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »DeKugelschieber« (09.02.2011, 18:11)

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

5

10.02.2011, 16:38

Hilfe...
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

6

10.02.2011, 16:46

Wo genau ist dein Problem. Du musst eben die Texturkoordinaten entsprechend wählen!? Jeder Vertex wird dazu seine eigenen Texturkoordinaten brauchen...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

7

10.02.2011, 17:07

Ich verstehe nicht ob ich jetzt für die vier Punkte die Texturkoordinaten angebe (also 6) oder für jedes Dreieck das mit Indicies erstellt wurde angeben muss (also 12). Zudem weiß ich nicht ob der die quadratische Textur jetzt über 2 Dreiecke zeichnet oder nur über 1.

Vorsicht Code!

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

class Map{  
    private:
        GLuint m_vBuffer, m_iBuffer, m_tBuffer, m_texture;
        vector<float> m_blocks;
        vector<unsigned int> m_share;
        vector<float> m_texCoords;
        float m_blockSize;
        unsigned int m_size;
        bool m_create;

    public:
        Map(GLuint vBuffer, GLuint iBuffer, GLuint tBuffer, float bs, GLuint texture){
            m_size = 0;
            m_blockSize = bs;
            m_vBuffer = vBuffer;
            m_iBuffer = iBuffer;
            m_tBuffer = tBuffer;
            m_texture = texture;
            m_create = true;
        }

        ~Map(){
            glDeleteBuffers(1, &m_vBuffer);
            glDeleteBuffers(1, &m_iBuffer);
        }

        void add(float x, float y, float z){
            float texCoord[] = {0.0, 1.0, 1.0};

            if(m_create){
                // Koordinaten, Incicies

                for(int i = 0; i < 12; i++){
                    m_texCoords.push_back(texCoord[0]);
                    m_texCoords.push_back(texCoord[1]);
                    m_texCoords.push_back(texCoord[2]);
                }
            }
            else{
                // direkt in VBO
            }

            m_size++;
        }

        void createData(){
            m_create = false;

            // Koordinaten
            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer);
            glBufferData(GL_ARRAY_BUFFER, m_size*24*sizeof(float), &m_blocks[0], GL_STATIC_DRAW); 

            // Koordinaten teilen
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iBuffer);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_size*36*sizeof(unsigned int), &m_share[0], GL_STATIC_DRAW); 

            // Texturkoordinaten
            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer);
            glBufferData(GL_ARRAY_BUFFER, m_size*3*12*sizeof(float), &m_texCoords[0], GL_STATIC_DRAW);  
        }

        void draw(){
            // VBOs erstellen
            if(m_create){
                createData();
            }

            glBindTexture(GL_TEXTURE_2D, m_texture);

            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iBuffer);           
            glVertexPointer(3, GL_FLOAT, 0, 0);

            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer);
            glTexCoordPointer(3, GL_FLOAT, 0, 0);
            
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);

            glDrawElements(GL_TRIANGLES, m_share.size(), GL_UNSIGNED_INT, 0);

            glDisableClientState(GL_VERTEX_ARRAY);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
};


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

// Textur laden
void loadTexture(char* path){ 
    TargaImage texture;
    
    if(!texture.load(path)){
        cout<<"Fehler beim laden der Textur"<<endl;    
    }
     
    glBindTexture(GL_TEXTURE_2D, textures[texturesIndex]);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D,
                 0,                      
                 GL_RGB8,          
                 texture.getWidth(),          
                 texture.getHeight(), 
                 0,       
                 GL_RGB,           
                 GL_UNSIGNED_BYTE,  
                 texture.getImageData());
                 
    texturesIndex++;
}
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »DeKugelschieber« (11.02.2011, 16:12)

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

8

10.02.2011, 17:16

Zitat von »DeKugelschieber«

Ich verstehe nicht ob ich jetzt für die vier Punkte die Texturkoordinaten angebe (also 6) oder für jedes Dreieck das mit Indicies erstellt wurde angeben muss (also 12). Zudem weiß ich nicht ob der die quadratische Textur jetzt über 2 Dreiecke zeichnet oder nur über 1.

Bei einem Würfel hast du an (zumindest einigen) Kanten zwangsweise Unstetigkeiten in den Texturkoordinaten. Daher wird es nicht möglich sein für jede Ecke nur einen Vertex zu haben da zumindest einige Vertices ihre eigenen Texturkoordinaten brauchen werden. Je nachdem wie schlau du dich anstellst wirst du für deinen Würfel wohl oder übel zumindest einige (wenn nicht alle) Vertices duplizieren müssen...
m4studios

Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »dot« (10.02.2011, 17:27)

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

9

10.02.2011, 22:36

Ich verstehs einfach nicht 8| ich speichere jetzt 2 Dreiecke (Koordinaten sind soweit auch richtig). Dazu speichere ich jetzt einmal Texturkoordinaten (0.0, 1.0, 1.0). Ausgabe wie folgt:

C-/C++-Quelltext

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

glBindTexture(GL_TEXTURE_2D, m_texture); // Textur

            glBindBuffer(GL_ARRAY_BUFFER, m_vBuffer); // Vertex     
            glVertexPointer(3, GL_FLOAT, 0, 0);

            glBindBuffer(GL_ARRAY_BUFFER, m_tBuffer); // Texturkoordinaten
            glTexCoordPointer(3, GL_FLOAT, 0, 0);
            
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);

            glDrawArrays(GL_TRIANGLES, 0, m_blocks.size()); // Ausgabe

            glDisableClientState(GL_VERTEX_ARRAY);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);


Das sieht dann so aus:


(Link)


Das witzige: wenn ich jetzt 2 mal Texturkoordinaten angebe wird die Textur auf dem zweiten Dreieck angezeigt, dazu allerdings nochmal um 90 grad gedreht, aber nicht mehr auf dem ersten! Ich werd langsam wahnsinnig!
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

10

10.02.2011, 22:41

Zitat von »DeKugelschieber«

Dazu speichere ich jetzt einmal Texturkoordinaten (0.0, 1.0, 1.0).

Was sollen das für Texturkoordinaten sein!? Jeder Vertex braucht ein (s, t) Texturkoordinaten Paar. Für 3 Vertices macht das 3 Paare bzw. 6 Texturkoordinaten...
m4studios

Werbeanzeige

  • 1
  • 2

Ähnliche Themen