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!

Shadow Mapping

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

18.07.2011, 15:04

Shadow Mapping

Hi Leute,

ich brauch eure Hilfe bein shadow mapping. So siehts bis jetzt aus:

Shadowmap:

(Link)


Gerendert:

(Link)


Zum einen glaube ich ist die Shadowmap falsch, die soll doch grauwerte haben oder so? Und vielleicht stimmt was an den Shadern nicht? Code:

Renderfunktion:

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

void render(){  
    moveObjects(); // Transformiert lediglich die Objekte

    glEnable(GL_DEPTH_TEST); // Tiefenvergleich

    // Lichtquelle
    glBindFramebuffer(GL_FRAMEBUFFER_EXT, shadowFBO);

    glViewport(0, 0, windowSize[0], windowSize[1]);
    glClear(GL_DEPTH_BUFFER_BIT);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, 1.0*windowSize[0]/windowSize[1], 0.1, 1000);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(lig.position[0], lig.position[1], lig.position[2],
              lig.lookat[0], lig.lookat[1], lig.lookat[2],
              view[6], view[7], view[8]);
    
    glCullFace(GL_FRONT);
    smRenderModels(); // Rendert die Modelle 
    
    glGetFloatv(GL_MODELVIEW_MATRIX, shadowMatrixModelview);
    glGetFloatv(GL_PROJECTION_MATRIX, shadowMatrixProjection);

    // Szene
    glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);

    glViewport(0, 0, windowSize[0], windowSize[1]);
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);   

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, 1.0*windowSize[0]/windowSize[1], 0.1, 1000);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(view[0], view[1], view[2],
              view[3], view[4], view[5],
              view[6], view[7], view[8]);
    
    glCullFace(GL_BACK);
    renderModels();
    
    glutSwapBuffers();
}


Modelle aus Lichtperspektive:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

void smRenderModels(){  
    glEnableVertexAttribArray(0); // Vertex

    for(unsigned int i = 0;  i < objects.size(); i++){      
        glPushMatrix();         
            glScalef(objects[i]->getScale(), objects[i]->getScale(), objects[i]->getScale());
            glTranslatef(objects[i]->getX(), objects[i]->getY(), objects[i]->getZ());
            glRotatef(objects[i]->getXRotation(), 1, 0, 0);
            glRotatef(objects[i]->getYRotation(), 0, 1, 0);
            glRotatef(objects[i]->getZRotation(), 0, 0, 1);
                                
            glBindBuffer(GL_ARRAY_BUFFER, objects[i]->getVertexBuffer());
            glVertexAttribPointer(GLint(0), 3, GL_FLOAT, GL_FALSE, 0, 0);
    
            glDrawArrays(GL_TRIANGLES, 0, objects[i]->getVerticesNumber());
        glPopMatrix();
    }

    glDisableVertexAttribArray(0);
}


Modelle aus Kameraperspektive:

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

void renderModels(){
    float modelviewMatrix[16];
    float projectionMatrix[16];
                
    // Shadow mapping
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, shadowMap);

    // Shader
    shader[0]->bindShader();

    shader[0]->sendUniform("texture0", 0);
    shader[0]->sendUniform("shadowMap0", 1);

    shader[0]->sendUniform4x4("shadow_modelview0", shadowMatrixModelview);
    shader[0]->sendUniform4x4("shadow_projection0", shadowMatrixProjection);
    shader[0]->sendUniform4x4("shadow_bias0", shadowMatrixBias);
    
    glEnableVertexAttribArray(0); // Vertex
    glEnableVertexAttribArray(1); // Textur
    glEnableVertexAttribArray(2); // Normalen

    for(unsigned int i = 0;  i < objects.size(); i++){      
        glPushMatrix();         
            glScalef(objects[i]->getScale(), objects[i]->getScale(), objects[i]->getScale());
            glTranslatef(objects[i]->getX(), objects[i]->getY(), objects[i]->getZ());
            glRotatef(objects[i]->getXRotation(), 1, 0, 0);
            glRotatef(objects[i]->getYRotation(), 0, 1, 0);
            glRotatef(objects[i]->getZRotation(), 0, 0, 1);

            glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix);
            glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix);
        glPopMatrix();
            
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, objects[i]->getTextureID()); // Textur

        shader[0]->sendUniform4x4("modelview_matrix", modelviewMatrix);
        shader[0]->sendUniform4x4("projection_matrix", projectionMatrix);
                                
        glBindBuffer(GL_ARRAY_BUFFER, objects[i]->getVertexBuffer());
        glVertexAttribPointer(GLint(0), 3, GL_FLOAT, GL_FALSE, 0, 0);
        glBindBuffer(GL_ARRAY_BUFFER, objects[i]->getTexCoordBuffer());
        glVertexAttribPointer(GLint(1), 2, GL_FLOAT, GL_FALSE, 0, 0);
        glBindBuffer(GL_ARRAY_BUFFER, objects[i]->getNormalBuffer());
        glVertexAttribPointer(GLint(2), 3, GL_FLOAT, GL_FALSE, 0, 0);
    
        glDrawArrays(GL_TRIANGLES, 0, objects[i]->getVerticesNumber());
    }

    glDisableVertexAttribArray(0);
    glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(2);
}


FBO:

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

void setupShadowMapping(){
    glGenTextures(1, &shadowMap); // Textur
    glBindTexture(GL_TEXTURE_2D, shadowMap);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    glTexImage2D(GL_TEXTURE_2D, 
                 0,
                 GL_DEPTH_COMPONENT24,
                 windowSize[0], 
                 windowSize[1],
                 0,
                 GL_DEPTH_COMPONENT, 
                 GL_UNSIGNED_BYTE, 
                 NULL);

    glGenFramebuffers(1, &shadowFBO); // FBO
    glBindFramebuffer(GL_FRAMEBUFFER, shadowFBO);
    glFramebufferTexture2D(GL_FRAMEBUFFER, 
                           GL_DEPTH_ATTACHMENT,
                           GL_TEXTURE_2D, 
                           shadowMap,
                           0);

    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}


Vertex Shader:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;

uniform mat4 shadow_matrix0; // Shadow mapping
uniform mat4 shadow_projection0; // Shadow mapping
uniform mat4 shadow_bias0; // Shadow mapping

in vec3 a_Vertex;
in vec2 a_TexCoord0;

out vec2 texCoord0;
out vec4 smTexCoord; // Shadow mapping

void main(void){        
    vec4 pos = modelview_matrix*vec4(a_Vertex, 1.0);

    texCoord0 = a_TexCoord0;    
    smTexCoord = shadow_matrix0*shadow_projection0*shadow_bias0*vec4(a_Vertex, 1.0); // Shadow mapping
    gl_Position = projection_matrix*pos;        
}


Fragment Shader:

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

precision highp float;

uniform sampler2D texture0;
uniform sampler2D shadowMap0; // Shadow mapping

in vec4 smTexCoord; // Shadow mapping
in vec2 texCoord0;

out vec4 outColor;

void main(void){    
    outColor = texture(texture0, texCoord0.st);

    // Shadow mapping
    vec3 scWdevide = smTexCoord.xyz/smTexCoord.w;
    scWdevide += 0.0005;

    float depth = texture(shadowMap0, smTexCoord.st).z;

    float shadow = 1.0;
    if(smTexCoord.w > 0.0){
        shadow = (depth < scWdevide.z) ? 0.5 : 1.0;
    }

    outColor *= shadow;
}


Was mach ich falsch?

MfG
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

  • Private Nachricht senden

2

18.07.2011, 22:12

Also zur Shadow Map, die speichert ja die Distanz von der Lichtquelle zu dem jeweiligen Punkt der gezeichnet worden ist. Ich nehme mal an, diese Distanz wird in deiner Szene typischerweise größer als 1.0 sein. Und wenn du dann die Shadow Maps einfach zeichnest wird der alles was größer als 1.0 ist einfach zu 1.0 abschneiden.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

3

18.07.2011, 23:38

Es wird nur eine Farbkomponente für die Berechnung genutzt (soweit ich das verstanden habe). Da durch sollte die Entfehrnung nicht größer als 1.0 sein... Aber wie man ja oben sieht ist alles weiß an den Stellen wo sich etwas befindet. Muss ich noch irgendwas aktivieren oder deaktivieren?
Falls jemand noch Quellen hat (nicht das was man bei Google auf den ersten zwei Seiten findet) her damit :)
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

4

19.07.2011, 06:49

Der Fakt, dass nur eine Farbkomponente benutzt wird, hat aber mit dem Clamp auf 1.0 nichts zu tun. Die gerenderte Range wird noch immer zu groß sein und daher wird alles auf 1.0 geschnitten, was darüber liegt - falls das das Problem ist.
Wo unbindest Du eigentlich den Shader?
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

5

19.07.2011, 13:03

Garnicht^^ ändert aber nichts an der Ausgabe. Ist jetzt drin:

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 render(){  
    moveObjects();

    glEnable(GL_DEPTH_TEST); // Tiefenvergleich

    // Lichtquelle
    //glBindFramebuffer(GL_FRAMEBUFFER_EXT, shadowFBO);
    glUseProgram(0);

    glViewport(0, 0, windowSize[0], windowSize[1]);
    glClear(GL_DEPTH_BUFFER_BIT);
    //glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, 1.0*windowSize[0]/windowSize[1], 0.1, 1000);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(lig.position[0], lig.position[1], lig.position[2],
              lig.lookat[0], lig.lookat[1], lig.lookat[2],
              view[6], view[7], view[8]);
    
    glCullFace(GL_FRONT);
    smRenderModels();
    
    glGetFloatv(GL_MODELVIEW_MATRIX, shadowMatrixModelview); // setTextureMatrix()
    glGetFloatv(GL_PROJECTION_MATRIX, shadowMatrixProjection);

    // Szene
    /*glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);

    glViewport(0, 0, windowSize[0], windowSize[1]);
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);   

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45, 1.0*windowSize[0]/windowSize[1], 0.1, 1000);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(view[0], view[1], view[2],
              view[3], view[4], view[5],
              view[6], view[7], view[8]);
    
    glCullFace(GL_BACK);
    renderModels();*/
    
    glutSwapBuffers();
}
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

6

19.07.2011, 14:45

Tjoar, Deine Shadow-Map ist ja auch noch immer auf 1 geclampt, weil die Werte vermutlich viel zu groß sind, die da im ersten Pass gerendert werden ;)
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

7

19.07.2011, 16:49

Und wie änder ich das? Hab alles so gemacht wie im Tutorial^^ (glaub ich).
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

  • Private Nachricht senden

8

19.07.2011, 19:34

Ich sehe gerade, dass du unsigned bytes benutzt um die Tiefeninformationen zu speichern. Damit ist das clampen nicht nur ein Anzeigeproblem. ;)

Das Format kann nur Werte von 0.0 bis 1.0 pro Komponente in 256 Stufen. Alles was drüber ist, wird zu 1.0 abgeschnitten, egal ob du nun einen "Helligkeitswert" oder eine RGBA-Farbe damit speicherst. Selbst wenn sich alles in diesem Bereich abspielen würde, die Genauigkeit für Shadow Mapping wäre grauenvoll. Da brauchst du eines der Float-Formate.
"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

DeKugelschieber

Community-Fossil

  • »DeKugelschieber« ist der Autor dieses Themas

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

9

20.07.2011, 11:46

hmm gut das kann ich ja mal gerade ändern, aber das Bild ganz oben ist ohne FBO gerendert und trotzdem komplett weiß. Also irgendwie ist das noch "Einstellungssache" beim rendern. Ich wüste jetzt aber nicht was fehlt.

[EDIT]

Was man aber unter anderem hier sieht: http://wiki.delphigl.com/index.php/GLSL_Licht_und_Schatten
Was machen die anders als ich?

[EDIT 2]

Ach kann es wohl sein das ich beim render aus Lichtperspektivedie Shadowmap über die Shader erzeuge? Weil momentan render ich komplett ohne (aus Lichtperspektive). Obwohl das hier auch nicht gemacht wird:

http://fabiensanglard.net/shadowmapping/index.php
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »DeKugelschieber« (20.07.2011, 12:33)

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

10

20.07.2011, 17:00

Ja, das ist dann der Punkt wo die dort eine Skalierung der Werte haben und Du nicht.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Werbeanzeige

Ähnliche Themen