spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// ===== Vertex-Shader =============================================
in vec4 position; // In worldspace

uniform mat4 light_vp_matrix; // View-Projection-matrix für die aktuelle Würfelseite der Cubemap, Far-plane: 40.0
uniform vec3 light_pos; // In worldspace

out vec4 var_light_to_vertex_ws;

void main(void)
{
  var_light_to_vertex_ws = position - vec4(light_pos, 1.0);
  gl_Position = light_vp_matrix * position;
}

// ===== Fragment-Shader =============================================
in vec4 var_light_to_vertex_ws;
out vec4 frag;

void main(void)
{
  float dist_from_light = length(var_light_to_vertex_ws.xyz)/40.0;
  frag = vec4(vec3(1.0, 1.0, 1.0) * dist_from_light, 1.0);
  // gl_FragDepth = dist_from_light; // Erzeugt die gleichen Ergebnisse, wie ohne diese Zeile.
}

C-/C++-Quelltext

// ===== Vertex-Shader =============================================
in vec4 position;
uniform vec3 light_position_ws;
uniform mat4 mvp_matrix;
out vec4 var_light_to_vertex_ws;
...

void main(void)
{
  var_light_to_vertex_ws = position - vec4(light_position_ws, 1.0);
  gl_Position = mvp_matrix * position;
  ...
}

// ===== Fragment-Shader =============================================
in vec4 var_light_to_vertex_ws;
uniform samplerCube shadow_map;
out vec4 frag;
...

void main(void)
{
  // Calculate shadow-map-depth of this fragment.
  vec3 shadow_map_dir   = normalize(var_light_to_vertex_ws).xyz;
  shadow_map_dir.xz     = -shadow_map_dir.xz; // Seltsamerweise sieht der Schatten etwas richtiger aus wenn ich xz negiere.
  float shadow_map_depth = texture(shadow_map, shadow_map_dir).r;

  // Calculate depth of this fragment.
  float frag_depth      = length(var_light_to_vertex_ws.xyz)/40.0;

  float is_in_light = 0.0;
  if (shadow_map_depth < frag_depth + 0.0005)
        is_in_light = 1.0;

  ...
}

C-/C++-Quelltext

  glBindVertexArray(m_terrain_vao);

  // Bind buffer for vertex indices and set data.
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_terrain_indices_buffer);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_terrain_indices.size()*sizeof(GLuint), &m_terrain_indices[0], GL_STATIC_DRAW);

  // Vec3f light_position(sin(0.001*g_now)*15.0, 6.0, [> 0.0); // <]cos(0.0005*g_now)*15.0);
  Vec3f light_position(0.0, 6.0, 0.0);

  // Create Matrices for the light
  Mat4f light_proj_matrix;
  light_proj_matrix.set_identity();
  light_proj_matrix.set_projection(90.0, 1.0, 1.0, 40.0);

  Mat4f light_vp_matrices[6];
  Mat4f light_v_matrices[6];
  for (size_t i = 0; i < 6; i++)
  {
    Vec3f cube_normal, cube_up;
    switch (i)
    {
    case 0: cube_normal.set( 1.0,  0.0,  0.0); cube_up.set( 0.0, -1.0,  0.0); break;
    case 1: cube_normal.set(-1.0,  0.0,  0.0); cube_up.set( 0.0, -1.0,  0.0); break;
    case 2: cube_normal.set( 0.0,  1.0,  0.0); cube_up.set( 0.0,  0.0,  1.0); break;
    case 3: cube_normal.set( 0.0, -1.0,  0.0); cube_up.set( 0.0,  0.0, -1.0); break;
    case 4: cube_normal.set( 0.0,  0.0,  1.0); cube_up.set( 0.0, -1.0,  0.0); break;
    case 5: cube_normal.set( 0.0,  0.0, -1.0); cube_up.set( 0.0, -1.0,  0.0); break;
    }
    light_v_matrices[i].set_identity();
    light_v_matrices[i].set_view(light_position, light_position + cube_normal, cube_up);
    light_vp_matrices[i] = light_proj_matrix * light_v_matrices[i];
  }

  // Render Shadow-Cube-Map
  glViewport(0, 0, 1024, 1024);
  m_shadow_shader.use();
  glBindFramebuffer(GL_FRAMEBUFFER, m_shadow_fbo);
  for (size_t i = 0; i < 6; i++)
  {
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,   GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, m_shadow_depth_cubemap_id, 0);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,  GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, m_shadow_color_cubemap_id, 0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glUniformMatrix4fv(m_shadow_shader.get_uniform_location("light_vp_matrix"),
                    1, false, (GLfloat*) &light_vp_matrices[i]);
    glUniformMatrix4fv(m_shadow_shader.get_uniform_location("light_v_matrix"),
                    1, false, (GLfloat*) &light_v_matrices[i]);
    glUniformMatrix4fv(m_shadow_shader.get_uniform_location("light_pos"),
                    1, false, (GLfloat*) &light_position);
    glDrawElements(GL_TRIANGLE_STRIP, m_terrain_indices.size(), GL_UNSIGNED_INT, 0);
  }
  
  // Draw Shadow-Cube-Map (die Debug-Skybox)
  glViewport(0, 0, (GLint)m_width, (GLint)m_height);
  glBindVertexArray(m_skybox_vao);
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  m_cubemap_shader.use();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  Mat4f mvp = proj_matrix * view_matrix;
  glUniformMatrix4fv(m_cubemap_shader.get_uniform_location("mvp_matrix"),
                    1, false, (GLfloat*) &mvp);
  glUniform1i(m_cubemap_shader.get_uniform_location("tex"), 0);
  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_CUBE_MAP, m_shadow_color_cubemap_id);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 19);
 
  // Draw Terrain
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  glBindVertexArray(m_terrain_vao);
  m_texture_lightning_shader.use();
  Mat4f a = view_matrix.invert().get_transposed();
  Mat3f normal_matrix(
    a[0], a[4], a[ 8],
    a[1], a[5], a[ 9],
    a[2], a[6], a[10]
  );
  Vec3f light_position_ls = view_matrix * light_position;

  glUniformMatrix4fv(m_texture_lightning_shader.get_uniform_location("mvp_matrix"),
                    1, false, (GLfloat*) &mvp);
  glUniformMatrix4fv(m_texture_lightning_shader.get_uniform_location("mv_matrix"),
                    1, false, (GLfloat*) &view_matrix);
  glUniformMatrix3fv(m_texture_lightning_shader.get_uniform_location("normal_matrix"),
                    1, false, (GLfloat*) &normal_matrix);
  glUniform3fv(m_texture_lightning_shader.get_uniform_location("light_position"),
                    1, (GLfloat*) &light_position_ls);
  glUniform3fv(m_texture_lightning_shader.get_uniform_location("light_position_ws"),
                    1, (GLfloat*) &light_position);

  Vec4f ambient_color(0.1, 0.1, 0.0, 1.0);
  Vec4f diffuse_color(1.0, sin(g_now*0.001)*0.5+0.5, cos(g_now*0.01)*0.5+0.5, 1.0);
  Vec4f specular_color(1.0, 1.0, 1.0, 1.0);

  glUniform4fv(m_texture_lightning_shader.get_uniform_location("ambient_color"),
                    1, (GLfloat*) &ambient_color);
  glUniform4fv(m_texture_lightning_shader.get_uniform_location("diffuse_color"),
                    1, (GLfloat*) &diffuse_color);
  glUniform4fv(m_texture_lightning_shader.get_uniform_location("specular_color"),
                    1, (GLfloat*) &specular_color);

  glUniformMatrix4fv(m_texture_lightning_shader.get_uniform_location("light_vp_matrix"),
                    1, false, (GLfloat*) &light_v_matrices[5]);

  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_2D, map->_texture_ids[0]);
  glUniform1i(m_texture_lightning_shader.get_uniform_location("tex"), 0);

  glActiveTexture(GL_TEXTURE1);
  glBindTexture(GL_TEXTURE_CUBE_MAP, m_shadow_color_cubemap_id);
  glUniform1i(m_texture_lightning_shader.get_uniform_location("shadow_map"), 1);

  glDrawElements(GL_TRIANGLE_STRIP, m_terrain_indices.size(), GL_UNSIGNED_INT, 0);

C-/C++-Quelltext

// ===== Vertex-Shader ===========================
#version 330

in vec4 position;
in vec3 normal;
in vec2 tex_coords;

uniform mat4 mvp_matrix;
uniform mat4 mv_matrix;
uniform mat3 normal_matrix;
uniform vec3 light_position;
uniform vec3 light_position_ws;
uniform mat4 light_vp_matrix;

out vec3 var_normal;
out vec3 var_light_dir;
out vec2 var_tex_coords;
out vec4 var_light_to_vertex_ws;
out vec4 var_position;

void main(void)
{
  /* var_light_to_vertex_ws = light_vp_matrix * position; */
  var_light_to_vertex_ws = position - vec4(light_position_ws, 1.0);

  var_tex_coords = tex_coords;

  // Get surface normal in eye coordinates
  var_normal = normal_matrix * normal;

  // Get vertex position in eye coordinates
  vec4 vPosition4 = mv_matrix * position;
  vec3 vPosition3 = vPosition4.xyz / vPosition4.w;

  // Get vector to light source
  var_light_dir = normalize(light_position - vPosition3);

  var_position = mvp_matrix * position;

  // Don’t forget to transform the geometry!
  gl_Position = var_position;
}

// ===== Fragment-Shader ==============================
#version 330

in vec3 var_normal;
in vec3 var_light_dir;
in vec2 var_tex_coords;
in vec4 var_light_to_vertex_ws;
in vec4 var_position;

uniform sampler2D tex;
uniform samplerCube shadow_map;
uniform vec4 ambient_color;
uniform vec4 diffuse_color;
uniform vec4 specular_color;

out vec4 frag;

void main(void)
{
  // Dot product gives us diffuse intensity
  float diff = max(0.0, dot(normalize(var_normal),
  normalize(var_light_dir)));

  // Add in ambient light
  frag = ambient_color;

  // Calculate shadow-map-depth of this fragment.
  vec3 shadow_map_dir   = normalize(var_light_to_vertex_ws).xyz;
  shadow_map_dir.xz     = -shadow_map_dir.xz;
  float shadow_map_depth = texture(shadow_map, shadow_map_dir).x;

  // Calculate depth of this fragment.
  float frag_depth      = length(var_light_to_vertex_ws.xyz)/40.0;

  // Multiply intensity by diffuse color
  if (shadow_map_depth < frag_depth + 0.0005)
    frag += vec4(diff * diffuse_color.xyz, 1.0);
  else
    diff = 0;

  // Specular Light
  vec3 vReflection = normalize(reflect(-normalize(var_light_dir),
  normalize(var_normal)));
  float spec = max(0.0, dot(normalize(var_normal), vReflection));

  // If the diffuse light is zero, don’t even bother with the pow function
  if (diff != 0)
  {
    float fSpec = pow(spec, 128.0);
    frag.rgb += vec3(fSpec, fSpec, fSpec);
  }

  frag = texture(tex, var_tex_coords) * frag;

// Diese Zeile erzeugt das 3. Bild in schwarz-weiß:
// frag = vec4(vec3(1.0, 1.0, 1.0)*shadow_map_depth, 1.0);
}

C-/C++-Quelltext

glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, GL_RGBA, width, width, 0, GL_RGBA, GL_FLOAT, 0);