Question

我正在使用JOGL将OpenGL SuperBible演示转换为Java。直到第12章的所有演示都进展顺利，但现在我陷入阴影映射。这是我的设置：

public class ShadowMap implements GLEventListener
{
    public static void main(String[] args)
    {
        ShadowMap rend = new ShadowMap();
        window.NEWTWindowStarter.init(rend, null, null);
    }

    private int light_program, camera_program;
    private int[] obj, bkg;

    private int camera_mv_pointer, camera_proj_pointer, light_mvp_pointer, camera_shadow_pointer;

    private int fbo, depth_tex;
    private int screen_width, screen_height;
    private float aspect;

    private double[] light_position, camera_position;
    private double[][] light_proj_matrix, light_view_matrix;
    private double[][] camera_proj_matrix, camera_view_matrix;
    private double[][] bias_matrix, shadow_matrix;
    private double[][] obj_model_matrix, bkg_model_matrix;

    @Override
    public void init(GLAutoDrawable glAutoDrawable)
    {
        GL4 gl = glAutoDrawable.getGL().getGL4bc();

        ObjectParser parser = new ObjectParser("pawn_s.obj");
        obj = BufferController.prepareVAO(gl, parser.getDataHolder());

        parser = new ObjectParser("bkg.obj");
        bkg = BufferController.prepareVAO(gl, parser.getDataHolder());

        light_program = ShaderController.init(gl, "shaders/demo/d25/light_v.glsl", "shaders/demo/d25/light_f.glsl");
        light_mvp_pointer = gl.glGetUniformLocation(light_program, "mvp");

        camera_program = ShaderController.init(gl, "shaders/demo/d25/camera_v.glsl", "shaders/demo/d25/camera_f.glsl");
        camera_mv_pointer = gl.glGetUniformLocation(camera_program, "mv_matrix");
        camera_proj_pointer = gl.glGetUniformLocation(camera_program, "proj_matrix");
        camera_shadow_pointer = gl.glGetUniformLocation(camera_program, "shadow_matrix");


        depth_tex = BufferController.generateTextureId(gl);
        gl.glBindTexture(gl.GL_TEXTURE_2D, depth_tex);
        gl.glTexStorage2D(gl.GL_TEXTURE_2D, 11, gl.GL_DEPTH_COMPONENT32F, 1024, 1024);

        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR);
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR);

        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER);
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER);

        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_COMPARE_MODE, gl.GL_COMPARE_REF_TO_TEXTURE);
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_COMPARE_FUNC, gl.GL_LEQUAL);

        gl.glActiveTexture(gl.GL_TEXTURE0);
        gl.glBindTexture(gl.GL_TEXTURE_2D, depth_tex);

        fbo = BufferController.generateFrameId(gl);
        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo);
        gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, depth_tex, 0);
        gl.glDrawBuffer(gl.GL_NONE);
        gl.glReadBuffer(gl.GL_NONE);

        if(gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) == gl.GL_FRAMEBUFFER_COMPLETE)
            System.out.println("FrameBuffer OK!");
        else
            System.out.println("FrameBuffer FAIL!");

        gl.glBindTexture(gl.GL_TEXTURE_2D, 0);
        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0);

        gl.glEnable(gl.GL_DEPTH_TEST);
    }


    @Override
    public void dispose(GLAutoDrawable glAutoDrawable){}

    @Override
    public void display(GLAutoDrawable glAutoDrawable)
    {
        GL4bc gl = glAutoDrawable.getGL().getGL4bc();

        computerMatrices();
        gl.glEnable(gl.GL_DEPTH_TEST);

        // depth pass
        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo);
        gl.glViewport(0, 0, 1024, 1024);

        gl.glUseProgram(light_program);
        drawFromLight(gl, obj, obj_model_matrix);
        drawFromLight(gl, bkg, bkg_model_matrix);

        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0);


        // final pass
        gl.glViewport(0, 0, screen_width, screen_height);
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT);
        gl.glBindTexture(gl.GL_TEXTURE_2D, depth_tex);
        gl.glDrawBuffer(gl.GL_BACK);

        gl.glUseProgram(camera_program);
        drawFromCamera(gl, obj, obj_model_matrix);
        drawFromCamera(gl, bkg, bkg_model_matrix);

        gl.glBindTexture(gl.GL_TEXTURE_2D, 0);
    }

    private void computerMatrices()
    {
        bkg_model_matrix = Matrix.model(0, 0, 0, 0, 0, 0, 1);
        obj_model_matrix = Matrix.model(0, 0, 0, 0, 0, 0, 1);

        light_position = new double[]{10, 10, 10};
        camera_position = new double[]{10, 0, 10};

        light_proj_matrix = Matrix.frustum(-1.0, 1.0, -1.0, 1.0, 1.0, 200.0);
        light_view_matrix = Matrix.lookAt(light_position, new double[]{0, 0, 0}, new double[]{0, 1, 0});

        camera_proj_matrix = Matrix.perspective(60, aspect, 0.1f, 1000f);
        camera_view_matrix = Matrix.lookAt(camera_position, new double[]{0, 0, 0}, new double[]{0, 1, 0});

        bias_matrix = new double[][]{
                {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}};

        shadow_matrix = Matrix.mult(bias_matrix, light_proj_matrix, light_view_matrix);
    }

    private void drawFromLight(GL4bc gl, int[] obj, double[][] model_matrix)
    {
        gl.glUniformMatrix4fv(light_mvp_pointer, 1, false, Matrix.toArrayF(Matrix.mult(light_proj_matrix, light_view_matrix, model_matrix)), 0);
        BufferControllerDep.renderTrianglesVAO(gl, obj[0], obj[1], obj[2]);
    }

    private void drawFromCamera(GL4bc gl, int[] obj, double[][] model_matrix)
    {
        gl.glUniformMatrix4fv(camera_shadow_pointer, 1, false, Matrix.toArrayF(Matrix.mult(shadow_matrix, model_matrix)), 0);
        gl.glUniformMatrix4fv(camera_proj_pointer, 1, false, Matrix.toArrayF(camera_proj_matrix), 0);
        gl.glUniformMatrix4fv(camera_mv_pointer, 1, false, Matrix.toArrayF(Matrix.mult(camera_view_matrix, model_matrix)), 0);
        BufferControllerDep.renderTrianglesVAO(gl, obj[0], obj[1], obj[2]);
    }

    @Override
    public void reshape(GLAutoDrawable glAutoDrawable, int x, int y, int width, int height)
    {
        screen_width = width;
        screen_height = height;
        aspect = (1.0f * screen_width) / screen_height;
    }
}

浅色着色器非常基本。 Camera Vertex着色器如下：

#version 430 core

uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
uniform mat4 shadow_matrix;

layout (location = 0) in vec4 position;
layout (location = 1) in vec3 normal;

out vec4 shadow_coord;

uniform vec3 light_pos = vec3(10.0, 10.0, 10.0);
out vec3 N;
out vec3 L;

void main(void)
{
    N = normalize(mat3(mv_matrix) * normal);
    L = normalize(light_pos - (mv_matrix * position).xyz);

    shadow_coord = shadow_matrix * position;

    gl_Position = proj_matrix * mv_matrix * position;
}

相机片段着色器：

#version 430 core

layout (location = 0) out vec4 color;

layout (binding = 0) uniform sampler2DShadow shadow_tex;

in vec4 shadow_coord;

uniform vec3 D = vec3(0.9, 0.8, 1.0);
in vec3 N;
in vec3 L;

void main(void)
{
    vec3 diffuse = dot(N, L) * D;

    float shadow = textureProj(shadow_tex, shadow_coord);

//    color = vec4(diffuse, 1.0);
    color = shadow * vec4(1);
}

只是渲染漫反射效果很好。 Projection，LookAt和Transformation矩阵似乎都有效。

但是，在尝试渲染阴影时，它会失败：

将光线移近物体会产生以下结果：

我使用自己的Matrix和Vector类，如果需要可以提供源代码。

任何见解都表示赞赏。谢谢！

Answer 1

问题是由Java代码中的反向矩阵乘法顺序引起的。这是更正后的代码：

private void drawFromLight(GL4bc gl, int[] obj, double[][] model_matrix)
{
    gl.glUniformMatrix4fv(light_mvp_pointer, 1, false,
            Matrix.toArrayF(Matrix.mult(model_matrix, light_view_matrix, light_proj_matrix)), 0);

    BufferControllerDep.renderTrianglesVAO(gl, obj[0], obj[1], obj[2]);
}

private void drawFromCamera(GL4bc gl, int[] obj, double[][] model_matrix)
{
    gl.glUniformMatrix4fv(camera_shadow_pointer, 1, false,
            Matrix.toArrayF(Matrix.mult(model_matrix, shadow_matrix)), 0);

    gl.glUniformMatrix4fv(camera_mv_pointer, 1, false,
            Matrix.toArrayF(Matrix.mult(model_matrix, camera_view_matrix)), 0);

    gl.glUniformMatrix4fv(camera_mvp_pointer, 1, false,
            Matrix.toArrayF(Matrix.mult(model_matrix, camera_view_matrix, camera_proj_matrix)), 0);

    BufferControllerDep.renderTrianglesVAO(gl, obj[0], obj[1], obj[2]);
}

使用相同的着色器会产生以下结果：

同时添加

gl.glEnable(gl.GL_POLYGON_OFFSET_FILL);
gl.glPolygonOffset(2.0f, 0.0f);

在执行＆＃34;光通过之前＆＃34;摆脱失真：

混合阴影和漫反射产生：

但是还有改进的余地......

JOGL阴影贴图

1 个答案: