Question

我正在从旧版->现代OpenGL迁移2D游戏。对我来说，这意味着使用着色器和顶点数组而不是glProjection，glOrtho和glBegin / glEnd。

我将相关代码简化为一个非常基本的示例。相机在（0，0，-1）处在（0，0，0）处，我试图绘制一个带有点的三角形：

(0, 0, 0)
      X
      | '
      |   '
      |     '
      X-------X
(0, 1, 0)   (1, 1, 0)

即使使用非常简单的着色器将所有片段渲染为白色，我也看不到这个三角形，只是闪烁的背景色。

代码

package client.render.opengl;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

import org.joml.Matrix4f;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFW;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;

import client.res.gfx.ScreenShader;

public class RenderingTest {

    private static final int NUM_VERTICES = 3;

    private static long window;
    private static int shaderProgram;
    private static int vao;
    private static int uniformLoc;
    private static Matrix4f viewProjMatrix = new Matrix4f();
    private static FloatBuffer fb16 = BufferUtils.createFloatBuffer(16);

    public static void main(String[] args) throws IOException {

        init();

        while (!GLFW.glfwWindowShouldClose(window)) {
            GLFW.glfwPollEvents();
            render();
            GLFW.glfwSwapBuffers(window);
        }
    }

    private static void init() throws IOException {

        // Setup an error callback
        GLFW.glfwSetErrorCallback(
                GLFWErrorCallback.createPrint(System.err)
        );

        // Initialise GLFW
        if (!GLFW.glfwInit()) {
            throw new IllegalStateException("Unable to initialize GLFW");
        }

        // Create window
        window = GLFW.glfwCreateWindow(800, 600, "test", 0, 0);
        GLFW.glfwMakeContextCurrent(window);
        GL.createCapabilities();
        GLFW.glfwShowWindow(window);

        // Load shader
        // Assume this code is good for now, it's too long to post here
        ScreenShader.initialise();
        shaderProgram = ScreenShader.shader.getProgram();
        uniformLoc = ScreenShader.shader.getUniformLoc(ScreenShader.UNIFORM_VIEW_PROJ_MATRIX);

        // Define our vertices
        ByteBuffer vertexBuffer = ByteBuffer.allocateDirect(NUM_VERTICES * 2 * Float.BYTES);
        vertexBuffer.putFloat(0).putFloat(0); // Vertex 1
        vertexBuffer.putFloat(0).putFloat(1); // Vertex 2
        vertexBuffer.putFloat(1).putFloat(1); // Vertex 3
        vertexBuffer.flip();

        // Create VAO
        vao = GL30.glGenVertexArrays();
        GL30.glBindVertexArray(vao);

        // Create VBO and fill it with vertex positions
        int vboIdPositions = GL15.glGenBuffers();
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboIdPositions);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertexBuffer, GL15.GL_STATIC_DRAW);
        GL20.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, 0, 0);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); // Deselect

        // Unbind the VAO
        GL30.glBindVertexArray(0);
    }

    public static void render() {

        // Render a random background to prove the loop is working
        GL11.glClearColor(
                (float) (Math.random() * 0.2f),
                (float) (Math.random() * 0.2f),
                (float) (Math.random() * 0.2f),
                1.0f);
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

        // Use shader
        GL20.glUseProgram(shaderProgram);

        // Get camera position
        float cameraX = 0;
        float cameraY = 0;

        // Set view and projection
        viewProjMatrix
                .setOrtho(
                        0,
                        800,
                        600,
                        0,
                        0.01f,
                        10
                ).lookAt(
                        cameraX, cameraY, -1,    // Camera position
                        cameraX, cameraY, 0,     // Camera "look" vector
                        0, 1, 0                  // Camera "up" vector
                );

        // Pass this matrix to our shader
        GL20.glUniformMatrix4fv(uniformLoc, false, viewProjMatrix.get(fb16));

        // Bind our vertex array
        GL30.glBindVertexArray(vao);

        // Enable vertex attributes
        GL20.glEnableVertexAttribArray(0);

        // Draw the vertices
        GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, NUM_VERTICES);

        // Disable vertex attributes
        GL20.glDisableVertexAttribArray(0);

        // Unbind vertex array
        GL30.glBindVertexArray(0);

        // Release shader
        GL20.glUseProgram(0);
    }

}

顶点着色器

#version 330

uniform mat4 view_proj_matrix;

layout(location = 0) in vec2 in_vertex;

void main(void) {
    gl_Position = view_proj_matrix * vec4(in_vertex, 0, 1);
}

片段着色器

#version 330

out vec4 frag_colour;

void main(void) {
    frag_colour = vec4(1, 1, 1, 1);
}

我不知道该如何进步，因为我什至无法使这个玩具示例正常工作。谁能看到我在做什么错，还是可以将我指向一个结合使用JOML和LWJGL2和着色器的工作示例？

Answer 1

使用您的视图和投影矩阵，三角形的大小为1像素，并且在屏幕的左侧。

如果三角形的坐标为（0，0，0），（0，1，0），（1，1，0），则窗口的大小为（800，600），并且您设置了正交投影与此链接：

viewProjMatrix.setOrtho(0, 800, 600, 0, 0.01f, 10)

三角形在屏幕上的大小为1像素。

您必须更改正投影：

float aspect = 800.0f/600.0f;
viewProjMatrix.setOrtho(-aspect, aspect, 1, -1, 0.01f, 10)

请注意，投影矩阵描述了从场景的3D点到视口的2D点的映射。在“正交投影”中，视图空间中的坐标被线性映射到剪辑空间坐标。

将其放大100倍，仍然没有迹象！

如果仅将三角形三角形缩放为（0，0，0），（0，100，0），（100，100，0），由于视图矩阵，您也不会看到三角形：

lookAt(0, 0, -1, 0, 0, 0, 0, 1, 0 );

使用此视图矩阵，x轴在Right-handed坐标系中反转。视图坐标系描述了从中查看场景的方向和位置。视图矩阵从世界空间转换为视图（眼睛）空间。在视图空间中，X轴指向左侧，Y轴指向上方，Z轴不在视图中（请注意，在右手系统中，Z轴是X轴与Y的叉积-轴）。

您的视图定义如下

position = (0, 0, -1)
center   = (0, 0, 0)
up       = (0, 1, 0)

y轴和z轴是这样的：

y-axis = up = (0, 1, 0)
z-axis = position - center = (0, 0, -1)

x轴是y轴和z轴的叉积：

x-axis = cross(y-axis, z-axis) = (-1, 0, 0)

这意味着，您看着三角形的背面。这导致三角形被“翻转”出视口。它绘制在屏幕的左侧，因此看不到它：

        (0, 0)
              X---------------------------x
            / |                           |
          /   |                           |
        X-----X                           |
(-100, 100)   |         viewport          |
              |                           |
              |                           |
              |                           |
              x---------------------------x 
                                            (800, 600)

反转视线以解决问题：

lookAt(0, 0, 1, 0, 0, 0, 0, 1, 0 );

Answer 2

您的着色器需要OpenGL 3.3。要使用Module.private_instance_methods使用此版本创建Core Profile，您可以调用：

GLFW

此外，似乎您以逆时针方向传递了顶点。因为GLFW.glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); GLFW.glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); GLFW.glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); window = GLFW.glfwCreateWindow(800, 600, "test", 0, 0);的默认值为glCullFace，所以这意味着您要查看的一面未呈现。更改顶点顺序或玩back，

无法渲染简单的顶点数组

2 个答案: