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!

GLSL mein erster Shader

Werbeanzeige

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

51

01.04.2011, 23:36

Zitat von »DeKugelschieber«

Wie soll das funktionieren? Der überschreibt doch dann jedes Vertice ^^. Das Bild bleibt auch so...

Achso du wolltest die vorhandenen Vertexdaten mitbenutzen...Das geht wie du schon festgestellt hast natürlich nur mit Indices. Oder du speicherst deine Daten z.B. wie oben interleaved und gibst beim Rendern des Modells den doppelten Stride an. Aber da es sich dabei nur um eine Debugfunktionalität handelt würd ich einfach einen eigenen Buffer zum Rendern der Normalen machen, sind die Vertexdaten dort halt nochmal drin, davon geht die Welt schon nicht unter ;)
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

52

02.04.2011, 11:58


(Link)


So sieht das jetzt aus, das rote render ich nach den Normalen (sind ein bisschen lang geworden).
Was soll uns das jetzt eigentlich sagen?

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

vector<Vertex> vec;
    vec.resize(m_interpolatedFrame.vertices.size()*2);

    for(unsigned int i = 0; i < vec.size()/2; i += 2){
        float x = m_interpolatedFrame.vertices[i].x+m_normals[i].x;
        float y = m_interpolatedFrame.vertices[i].y+m_normals[i].y;
        float z = m_interpolatedFrame.vertices[i].z+m_normals[i].z;
        float l = sqrt(x*x+y*y+z*z);

        vec[i].x = l/x;
        vec[i].y = l/y;
        vec[i].z = l/z;

        vec[i+1].x = m_interpolatedFrame.vertices[i].x;
        vec[i+1].y = m_interpolatedFrame.vertices[i].y;
        vec[i+1].z = m_interpolatedFrame.vertices[i].z;
    }

    m_debug.resize(vec.size());
    m_debug = vec;

    glGenBuffers(1, &m_debugBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_debugBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*m_debug.size()*3, &m_debug[0], GL_DYNAMIC_DRAW);
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

53

02.04.2011, 12:20

Warum normalisierst du die Position!? Du musst die Richtung der Normalen normalisieren, nicht die Position von irgendwelchen Vertices...und wenn dann x/l und nicht umgekehrt...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

54

02.04.2011, 13:03

Ist die Richtung der Normalen nicht schon normalisiert? Vielleicht hab ich genau dass ja einfach falsch 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

void md2Model::generateNormals(){
    vector<Vertex> normals;
    normals.resize(m_interpolatedFrame.vertices.size());

    for(unsigned int i = 0; i < m_interpolatedFrame.vertices.size(); i++){
        float x = m_interpolatedFrame.vertices[i].x;
        float y = m_interpolatedFrame.vertices[i].y;
        float z = m_interpolatedFrame.vertices[i].z;
        float l = sqrt(x*x+y*y+z*z);

        normals[i].x = l/x;
        normals[i].y = l/y;
        normals[i].z = l/z;
    }

    m_normals.resize(normals.size());
    m_normals = normals;

    glGenBuffers(1, &m_normalBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_normalBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*m_normals.size()*3, &m_normals[0], GL_DYNAMIC_DRAW);
};
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

55

02.04.2011, 13:48

Selber Fehler wie oben: x/l nicht l/x...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

56

02.04.2011, 14:01

Nagut ich änder das dann mal gerade :)
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

57

02.04.2011, 14:15

So das muss jetzt aber mal passen:


(Link)


Irgendwie sind wir von Thema abgekommen...

Naja mit richtigen Normalen siehts dann so aus:


(Link)
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »DeKugelschieber« (02.04.2011, 14:27)

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

58

02.04.2011, 14:44

Wie berechnest du denn die Normalen, die schaun irgendwie nicht wirklich korrekt aus...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

59

02.04.2011, 14:59

Bin mir gerade nicht ganz sicher ob die obere Grafik jetzt mit den neuen Normalen war...

Aber jetzt so:

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

void md2Model::generateNormals(){
    vector<Vertex> normals;
    normals.resize(m_interpolatedFrame.vertices.size());

    for(unsigned int i = 0; i < m_interpolatedFrame.vertices.size(); i++){
        float x = m_interpolatedFrame.vertices[i].x;
        float y = m_interpolatedFrame.vertices[i].y;
        float z = m_interpolatedFrame.vertices[i].z;
        float l = sqrt(x*x+y*y+z*z);

        normals[i].x = x/l;
        normals[i].y = y/l;
        normals[i].z = z/l;
    }

    m_normals.resize(normals.size());
    m_normals = normals;

    glGenBuffers(1, &m_normalBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_normalBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*m_normals.size()*3, &m_normals[0], GL_DYNAMIC_DRAW);
};
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

60

02.04.2011, 15:26

Naja, jetzt ist die Normalisierung korrekt aber die Berechnung ist wie schon ganz am Anfang gesagt falsch. Die Normale eines Dreiecks berechnest du über das Kreuzprodukt von zwei Kantenvektoren.
m4studios

Werbeanzeige

Ähnliche Themen