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

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

61

02.04.2011, 15:59

Warum sagst du das nicht gleich? ^^ Ich weiß jetzt gerade nicht wo ich das ändern muss... Im Shader? Ich muss nochmal gucken.

[EDIT]

Ach ich glaub ich habs kapiert...
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

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

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

62

02.04.2011, 17:38


(Link)


Kann auch nicht richtig sein oder?

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

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

    for(unsigned int i = 0; i < m_interpolatedFrame.vertices.size(); i += 3){
        Vertex A, B, C, a, b, v;

        A.x = m_interpolatedFrame.vertices[i].x;
        A.y = m_interpolatedFrame.vertices[i].y;
        A.z = m_interpolatedFrame.vertices[i].z;

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

        C.x = m_interpolatedFrame.vertices[i+2].x;
        C.y = m_interpolatedFrame.vertices[i+2].y;
        C.z = m_interpolatedFrame.vertices[i+2].z;

        a.x = B.x-A.x;
        a.y = B.y-A.y;
        a.z = B.z-A.z;

        b.x = C.x-A.x;
        b.y = C.y-A.y;
        b.z = C.z-A.z;

        v.x = (a.y*b.z)-(a.z*b.y);
        v.y = (a.z*b.x)-(a.x*b.z);
        v.z = (a.x*b.y)-(a.y*b.x);
        float l = sqrt(v.x*v.x+v.y*v.y+v.z*v.z);
        v.x = v.x/l;
        v.y = v.y/l;
        v.z = v.z/l;

        for(int c = 0; c < 2; c++){
            normals[i+c].x = v.x;
            normals[i+c].y = v.y;
            normals[i+c].z = v.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);
};


Ich hab versucht die Normale jetzt pro Dreieck zu rechnen.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

63

02.04.2011, 17:58

Ja das schaut schon nach was aus. Allerdings musst du bedenken dass ein Vertex zu mehreren Dreiecken gehören kann. Der einfachste Weg ist alle Vertexnormalen mit 0 zu Initialisieren, die noch unnormalisierten Normalen von jedem Dreieck zu den Vertexnormalen aller Vertices des Dreiecks zu addieren und erst in einem letzten Durchlauf alle Vertexnormalen abschließend zu normalisieren. Damit bekommst du schön nach der Dreiecksfläche gewichtete Vertexnormalen. Nachteil is natürlich dass du damit keine scharfen Kanten darstellen kannst, dafür müsstest du die Vertices mit verschiedenen Normalen duplizieren. Bei deinem Modell da oben könnte das z.B. bei den Tragflächen zu unerwünschten Ergebnissen führen.
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

64

02.04.2011, 20:11

Ich hoffe dass das jetzt passt:


(Link)


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

void md2Model::generateNormals(){
    vector<Vertex> normals;
    vector<Vertex> vertexNormals;

    normals.resize(m_interpolatedFrame.vertices.size());
    vertexNormals.resize(m_interpolatedFrame.vertices.size());

    // Alle Vertices normalisieren
    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);

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

    // Normalen Dreiecke
    for(unsigned int i = 0; i < m_interpolatedFrame.vertices.size(); i += 3){
        Vertex A, B, C, a, b, normal;
        float l;

        A.x = m_interpolatedFrame.vertices[i].x; // Ecke des Dreiecks
        A.y = m_interpolatedFrame.vertices[i].y;
        A.z = m_interpolatedFrame.vertices[i].z;

        B.x = m_interpolatedFrame.vertices[i+1].x; // Ecke des Dreiecks
        B.y = m_interpolatedFrame.vertices[i+1].y;
        B.z = m_interpolatedFrame.vertices[i+1].z;

        C.x = m_interpolatedFrame.vertices[i+2].x; // Ecke des Dreiecks
        C.y = m_interpolatedFrame.vertices[i+2].y;
        C.z = m_interpolatedFrame.vertices[i+2].z;

        a.x = B.x-A.x;
        a.y = B.y-A.y;
        a.z = B.z-A.z;

        b.x = C.x-A.x;
        b.y = C.y-A.y;
        b.z = C.z-A.z;

        normal.x = (a.y*b.z)-(a.z*b.y); // Normale des Dreiecks
        normal.y = (a.z*b.x)-(a.x*b.z);
        normal.z = (a.x*b.y)-(a.y*b.x);
        l = sqrt(normal.x*normal.x+normal.y*normal.y+normal.z*normal.z); // Laenge der Normalen des Dreiecks

        normals[i].x = (A.x+normal.x)/l;
        normals[i].y = (A.y+normal.y)/l;
        normals[i].z = (A.z+normal.z)/l;
        
        normals[i+1].x = (B.x+normal.x)/l;
        normals[i+1].y = (B.y+normal.y)/l;
        normals[i+1].z = (B.z+normal.z)/l;

        normals[i+2].x = (C.x+normal.x)/l;
        normals[i+2].y = (C.y+normal.y)/l;
        normals[i+2].z = (C.z+normal.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);
};


Der rote Kreis ist jetzt nicht ganz so schlimm.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

65

03.04.2011, 10:14

Verwendest du keine Indices? In dem Fall brauchst du das mit dem Zusammengewichten mehrerer Normalen natürlich nicht machen. Was ich mich so oder so frag ist warum du die Normalen mit den normalsierten Ortsvektoren initialisierst, aber nochmal: Die Vertexpositionen zu normalisieren ist einfach nur Sinnlos, das war gestern schon so, ist heute nicht anders und auch bis morgen wird sich nichts dran ändern.
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

66

03.04.2011, 11:04

Zitat

Was ich mich so oder so frag ist warum du die Normalen mit den normalsierten Ortsvektoren initialisierst


Ich will für jeden Ortsvektor nachher eine Normale oder nicht? Und wieso initialisieren? Ich mach doch nur den Vektor so groß wie den der Ortsvektoren. Am Ende füll ich den dann mit dem normalisierten Kreuzprodukt eines Dreiecks, ich glaub die Vertices für die Dreiecke lagen direkt hintereinander, muss aber nicht sein, ich hab nicht alles an der Klasse selber geschrieben (Buch).

Kannst du mir vielleicht ein Bild geben auf dem man sieht wohin die Normalen nachher zeigen? Dann kann ich die ja nochmal ausgeben.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

67

03.04.2011, 11:18

Zitat von »DeKugelschieber«

Ich will für jeden Ortsvektor nachher eine Normale oder nicht?

Jeder Vertex braucht eine Normale.

Zitat von »DeKugelschieber«

Und wieso initialisieren? Ich mach doch nur den Vektor so groß wie den der Ortsvektoren. Am Ende füll ich den dann mit dem normalisierten Kreuzprodukt eines Dreiecks, [...]

Ok, deine "normals" sind also nicht die Normalen sondern die Eckpunkte der Linien mit denen du die Normalen dann rendern willst oder wie!? Irgendwie kenn ich mich grad nicht aus, ist dir klar was der Unterschied zwischen einem Punkt und einem Richtungsvektor ist? Ich hab fast das Gefühl du glaubst Normalen sind irgendwelche Positionen, das ist aber eben nicht so!? Ist dir eigentlich klar was es bedeutet einen Vektor zu normalisieren? Die Worte "Normale" und "normalisieren" schauen zwar ähnlich aus bezeichnen aber zwei vollkommen unabhängige Dinge.

Zitat von »DeKugelschieber«

[...] ich glaub die Vertices für die Dreiecke lagen direkt hintereinander, muss aber nicht sein, ich hab nicht alles an der Klasse selber geschrieben (Buch).

Ohne das zu wissen ist es leider unmöglich auf eine richtige Lösung zu kommen...

Zitat von »DeKugelschieber«

Kannst du mir vielleicht ein Bild geben auf dem man sieht wohin die Normalen nachher zeigen? Dann kann ich die ja nochmal ausgeben.

Normalen stehen normal auf ihre Dreiecke und da kannst du die Korrektheit ja eben ganz einfach prüfen indem du die Normalen und Dreiecke anzeigst...
m4studios

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

68

03.04.2011, 12:07

Ich komm langsam mit den Begriffen etwas durcheinander. Aber meine Vorstellung davon sieht jetzt so aus:

1. Für die Schattierung wird geguckt ob die Normale des Dreiecks (berechnet aus Kreuzprodukt zweier Ecken, dann normalisiert) in Richtung der Lichtquelle zeigt.
2. Ich erstelle also für jedes Dreieck 3 Normale die alle gleich sind (Normale des Dreiecks aus Punkt 1) und setze sie auf die Vertices.

Zitat

Ok, deine "normals" sind also nicht die Normalen sondern die Eckpunkte der Linien mit denen du die Normalen dann rendern willst oder wie!?


Die Normalen jedes Vertices...

Zitat

Ohne das zu wissen ist es leider unmöglich auf eine richtige Lösung zu kommen...


Ich hab noch einen Member m_triangles in den die Indices der Vertices und der Texturkoordinaten jedes Dreiecks gespeichert sind.

Ich kopier mir jetzt einfach mal die Funktion aus meinem Buch und versuch sie anzupassen...
Wahrscheinlich hängts wieder an meiner nicht vorhandenen Übersicht über alle Daten und wie sie im Verhältnis stehen (nicht das mein Code nicht ordentlich währe).
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

69

03.04.2011, 12:24

Gelöscht
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »DeKugelschieber« (03.04.2011, 17:44)

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

70

03.04.2011, 16:18

So hier jetzt mal das ganze überarbeitet, ich find den Fehler aber einfach nicht:

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

Vector3 md2Model::cross(Vector3 a, Vector3 b){
    Vector3 v;
    v.x = (a.y*b.z)-(a.z*b.y);
    v.y = (a.z*b.x)-(a.x*b.z);
    v.z = (a.x*b.y)-(a.y*b.x);

    return v;
};

void md2Model::generateNormals(){
    vector<Vertex> normals;
    vector<int> shareCount;

    normals.resize(m_interpolatedFrame.vertices.size());
    shareCount.resize(m_interpolatedFrame.vertices.size());

    for(unsigned int i = 0; i < shareCount.size(); i++){
        shareCount[i] = 0;
    }

    for(unsigned int i = 0; i < m_triangles.size(); i++){
        Vertex A, B, C;
        Vector3 a, b, normal;

        A = m_interpolatedFrame.vertices[m_triangles[i].vertexIndex[0]];
        B = m_interpolatedFrame.vertices[m_triangles[i].vertexIndex[1]];
        C = m_interpolatedFrame.vertices[m_triangles[i].vertexIndex[2]];

        a.x = B.x-A.x;
        a.y = B.y-A.y;
        a.z = B.z-A.z;

        b.x = C.x-A.x;
        b.y = C.y-A.y;
        b.z = C.z-A.z;

        normal = cross(a, b);
        normal.normalize();

        for(int c = 0; c < 3; c++){
            int index = i*3+c;

            normals[index].x = normal.x;
            normals[index].y = normal.y;
            normals[index].z = normal.z;
            shareCount[index]++;
        }
    }

    for(unsigned int i = 0; i < m_interpolatedFrame.vertices.size(); i++){
        Vector3 v;

        v.x = normals[i].x/shareCount[i];
        v.y = normals[i].y/shareCount[i];
        v.z = normals[i].z/shareCount[i];
        v.normalize();
            
        normals[i].x = v.x;
        normals[i].y = v.y;
        normals[i].z = v.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);
};


m_triangles enhält alle Indices (für jedes Dreieck).

Ausgabe:


(Link)


Jetzt lass mich nicht hängen ^^
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »DeKugelschieber« (03.04.2011, 17:49)

Werbeanzeige

Ähnliche Themen