Sorry, muss arbeiten, deswegen so spät.
Also um das nochmal zusammenzufassen:
1. FBO erstellen
2. Depth Textur erstellen
3. Depth Textur an FBO binden
4. Tiefenvergleich aktivieren
5. FBO binden, Textur binden
6. glClear -> DEPTH_BUFFER
7. In Kameraview transformieren + Matrizen usw.
8. rendern
9. alles wieder entbinden
10. glClear
11. Viewport blabla
12. rendern
Und Shader nur für den zweiten Renderdurchgang. Der bekommt dann die Depthmap und die Matrizen der Lichtperspektive.
So jetzt hier nochmal mein FBO mit der Textur:
|
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
|
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_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_DEPTH_COMPONENT,
windowSize[0],
windowSize[1],
0,
GL_DEPTH_COMPONENT,
GL_UNSIGNED_BYTE,
NULL);
glGenFramebuffers(1, &shadowFBO); // FBO
glBindFramebuffer(GL_FRAMEBUFFER, shadowFBO);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_TEXTURE_2D,
shadowMap,
0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
Das rendern selbst:
|
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
|
glEnable(GL_DEPTH_TEST); // Tiefenvergleich
// Lichtquelle
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER_EXT, shadowFBO);
glBindTexture(GL_TEXTURE_2D, shadowMap);
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);
glGetFloatv(GL_PROJECTION_MATRIX, shadowMatrixProjection);
// Szene
glBindTexture(GL_TEXTURE_2D, 0);
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();
|
Und wo ich mir gut vorstellen könnte das die Daten falsch an den Shader übergeben werden (obwohl das so richtig sein müsste, aber was weiß ich schon):
|
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
|
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);
|
Naja und schließlich die Shader:
|
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
|
// Vertexshader:
uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;
uniform mat4 shadow_modelview0;
uniform mat4 shadow_projection0;
uniform mat4 shadow_bias0;
in vec3 a_Vertex;
in vec2 a_TexCoord0;
out vec2 texCoord0;
out vec4 shadowCoord;
void main(void){
mat4 TM = shadow_modelview0*shadow_projection0*shadow_bias0;
vec4 pos = modelview_matrix*vec4(a_Vertex, 1.0);
texCoord0 = a_TexCoord0;
shadowCoord = TM*vec4(a_Vertex, 1.0);
gl_Position = projection_matrix*pos;
}
// Fragmentshader:
precision highp float;
uniform sampler2D texture0;
uniform sampler2D shadowMap0; // Shadow mapping
in vec4 shadowCoord; // Shadow mapping
in vec2 texCoord0;
out vec4 outColor;
void main(void){
outColor = texture(texture0, texCoord0.st);
// Shadow mapping
vec3 scWdevide = shadowCoord.xyz/shadowCoord.w;
scWdevide += 0.0005;
float depth = texture(shadowMap0, shadowCoord.st).z;
float shadow = 1.0;
if(shadowCoord.w > 0.0){
shadow = (depth < scWdevide.z) ? 0.5 : 1.0;
}
outColor *= shadow;
}
|
So, das ist alles. Und es liegt höchstwahrscheinlich daran das ich nicht richtig in die Depthmap rendere...
Muss ich die Textur z.B. überhaupt binden?
Ist alles richtig deaktiviert/aktiviert?
Sollte ich die Matrizen für die shadowCoord (im Shader) vorher berechnen (wollte ich sowieso, ist jetzt nur zu Testzwecken so ineffizient)?
Liegt es vielleicht am Clipping (zNear 0.1 und zFar 1000)?
Ich find keinen (guten) kompletten Code dazu und das da oben ist alles was mir mein (jetziges) GL verständnis aus PDFs und Büchern hergibt... Und zaubern kann ich auch nicht
Ich hoffe ich nerve noch nicht
MfG
PS: Ich versuch mal schneller zu antworten... ( Schichtarbeit :/ )