INIT:

    glGenTextures(1, &shadowmap_);
    glBindTexture(GL_TEXTURE_2D, shadowmap_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 512, 512, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);

    glGenRenderbuffers(1, &renderbuffer_);
    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, 512, 512);

    glGenFramebuffers(1, &framebuffer_);
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowmap_, 0);

    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
    if(status != GL_FRAMEBUFFER_COMPLETE) {
        std::cout << "framebuffer fail\n";
    }

RENDER:
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_);
    //glDrawBuffer(GL_NONE);
    //glReadBuffer(GL_NONE);

    glClearColor(0.5, 0.2, 0.1, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // position the light
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos_);

    // set up the projection parameters from the light's POV
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
        glLoadIdentity();
        gluPerspective(lightFOV_, lightAspect_, lightNear_, lightFar_);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
        glLoadIdentity();
        // translate to the light's position
        gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2], -1.0f, 0.0f, 5.0f, 0.0f, 1.0f, 0.0f);

        // render the scene to get the depth information
        renderSceneElements();
    glPopMatrix();

    // end the projection modification
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    // copy over the depth information
    //glBindTexture(GL_TEXTURE_2D, shadowmap_);
    //glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 512, 512);

    // matrix defining the planes for S, T, R, Q components for texture generation
    float planeMatrix[16];
    glPushMatrix();
        glLoadIdentity();
        // compensate for the eye-coordinate to texture coordinate conversion: [-1,1] to [0,1]
        glTranslatef(0.5f, 0.5f, 0.5f);
        glScalef(0.5f, 0.5f, 1.0f);

        // do the perspective projection and translate to the light's position
        gluPerspective(lightFOV_, lightAspect_, lightNear_, lightFar_);
        gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2], -1.0f, 0.0f, 5.0f, 0.0f, 1.0f, 0.0f);

        glGetFloatv(GL_MODELVIEW_MATRIX, planeMatrix);
    glPopMatrix();

    // go from OpenGL's column-major to row-major matrix form
    transposeMatrix16(planeMatrix);

    // set up the type for texture generation
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    // data for texture generation
    glTexGenfv(GL_S, GL_OBJECT_PLANE, &planeMatrix[0]);
    glTexGenfv(GL_T, GL_OBJECT_PLANE, &planeMatrix[4]);
    glTexGenfv(GL_R, GL_OBJECT_PLANE, &planeMatrix[8]);
    glTexGenfv(GL_Q, GL_OBJECT_PLANE, &planeMatrix[12]);

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable(GL_TEXTURE_GEN_R);
    glEnable(GL_TEXTURE_GEN_Q);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
    glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);

    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, shadowmap_);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    renderSceneElements();

    glDisable(GL_LIGHTING);
    glDisable(GL_LIGHT0);

    glDisable(GL_TEXTURE_2D);

    glDisable(GL_TEXTURE_GEN_Q);
    glDisable(GL_TEXTURE_GEN_R);
    glDisable(GL_TEXTURE_GEN_T);
    glDisable(GL_TEXTURE_GEN_S);

    glPushMatrix();
        glEnable(GL_TEXTURE_2D);
        //glBindTexture(GL_TEXTURE_2D, shadowmap_);
        glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_NONE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
        glTranslatef(3.0f, 2.0f, 5.0f);
        glBegin(GL_QUADS);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(0.0f, 0.0f, 0.0f);

            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(3.0f, 0.0f, 0.0f);

            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(3.0f, 3.0f, 0.0f);

            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(0.0f, 3.0f, 0.0f);
        glEnd();
        glDisable(GL_TEXTURE_2D);
    glPopMatrix();