JOGL отображение теней

Question

Я перевожу демонстрации OpenGL SuperBible на Java, используя JOGL. Все демонстрации до 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;
    }
}

Легкие шейдеры очень просты. Камера Vertex Shader выглядит следующим образом:

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

Просто рендеринг diffuse работает нормально. Матрицы 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);

перед выполнением "светового пасса" избавляется от искажений:

Смешивание теней и рассеивание производит это:

Однако все еще есть возможности для улучшения...