spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void setTextureMatrix(void)
{
    static double modelView[16];
    static double projection[16];
    
    // This is matrix transform every coordinate x,y,z
    // x = x* 0.5 + 0.5 
    // y = y* 0.5 + 0.5 
    // z = z* 0.5 + 0.5 
    // Moving from unit cube [-1,1] to [0,1]  
    const GLdouble bias[16] = { 
        0.5, 0.0, 0.0, 0.0, 
        0.0, 0.5, 0.0, 0.0,
        0.0, 0.0, 0.5, 0.0,
    0.5, 0.5, 0.5, 1.0};
    
    // Grab modelview and transformation matrices
    glGetDoublev(GL_MODELVIEW_MATRIX, modelView);
    glGetDoublev(GL_PROJECTION_MATRIX, projection);
    
    
    glMatrixMode(GL_TEXTURE);
    glActiveTextureARB(GL_TEXTURE7);
    
    glLoadIdentity();   
    glLoadMatrixd(bias);
    
    // concatating all matrice into one.
    glMultMatrixd (projection);
    glMultMatrixd (modelView);
    
    // Go back to normal matrix mode
    glMatrixMode(GL_MODELVIEW);
}

C-/C++-Quelltext

out vec4 shadowCoord;

...

shadowCoord = shadow_matrix0*shadow_projection0*shadow_bias0*vec4(a_Vertex, 1.0);

C-/C++-Quelltext

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);

C-/C++-Quelltext

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();

C-/C++-Quelltext

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);

Quellcode

// 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;
}