渲染 3D LWJGL 平坦地形不起作用

Question

import static org.lwjgl.glfw.GLFW.*;
import  static org.lwjgl.opengl.GL11.*;
import  static org.lwjgl.opengl.GL20.*;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import  static org.lwjgl.opengl.GL15.*;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFWCursorPosCallback;
import   org.lwjgl.opengl.GL;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.system.MemoryUtil;
import org.lwjgl.util.vector.Matrix4f;
import org.lwjgl.util.vector.Vector3f;
import org.lwjgl.util.vector.Vector4f;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;

public class man {
private static final int VERTEX_COUNT = 128;
private static final float SIZE = 1;
public static int count;
public static int vid;
public static int iid;

public static int program;
public static float fov = 70f;
public static float near = 0.1f;
public static float far = 1000f;
public static Matrix4f modelMatrix = new Matrix4f() ;
public static Matrix4f view = new Matrix4f();
public static Matrix4f projectionmatrix = new Matrix4f();


public static GLFWCursorPosCallback mouseCallback;
public static boolean t = true;
    public static void main(String[] argv) throws IOException {
        glfwInit();
        int prog = 0 , id=0;
      long window =  glfwCreateWindow(1920, 
              1080, "HI", 0 , 0);

      glfwShowWindow(window);

      glfwMakeContextCurrent(window);

      GL.createCapabilities();

    //  glfwSetCursorPosCallback(window, mouseCallback = new mouse());

      while (!glfwWindowShouldClose(window))
      {


          glfwSwapBuffers(window);
          glfwPollEvents();
           new man().createShader();
          new man().bind();


        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_COLOR_BUFFER_BIT);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glLoadIdentity();
        glEnable(GL_PROJECTION_MATRIX);
        glEnable(GL_PROJECTION);

        new man().createprojection();
        new man().createview();
        glUseProgram(program);
        new man().loadtoshader();
         glEnableClientState(GL_VERTEX_ARRAY);
        glBindBuffer(GL_ARRAY_BUFFER, vid);
        glVertexPointer(3, GL_FLOAT , 0, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iid);
        glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, 0);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glDisable(GL_VERTEX_ARRAY);

      }
    }



    public void createShader() throws IOException
    {
        StringBuilder vertex = new StringBuilder();
        StringBuilder  frag = new StringBuilder();
        BufferedReader vert ,fragment;
        vert = new BufferedReader(new FileReader("D:/work/opengl2/src/opengl2/vertexShader.txt"));
        fragment = new BufferedReader(new FileReader("D:/work/opengl2/src/opengl2/frageShader.txt"));
        //vertex Shader
        String line, line2;
        while ( (line =  vert.readLine()) != null)
        {
            vertex.append(line).append('n');
        }
        while ( (line2 =  fragment.readLine()) != null)
        {
            frag.append(line2).append('n');
        }
        //create and comile shaders
            int vertexShader = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
            GL20.glShaderSource(vertexShader, vertex);
            GL20.glCompileShader(vertexShader);
            int fragmentShader = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
            GL20.glShaderSource(fragmentShader, frag);
            GL20.glCompileShader(fragmentShader);
             program = GL20.glCreateProgram();

            GL20.glAttachShader(program, vertexShader);
            GL20.glAttachShader(program, fragmentShader);           
            GL20.glBindAttribLocation(program, 0 , "postion");

            GL20.glLinkProgram(program);

            if (GL20.glGetProgrami(program, GL20.GL_LINK_STATUS) != 1)
            {
                System.err.println(GL20.glGetProgramInfoLog(program));
                System.exit(1);
            }

            GL20.glValidateProgram(program);
    }

    public void bind()
    {
        float[] vertices = new float[128 * 128 * 3];
        int[] indices = new int[6*(VERTEX_COUNT-1)*(VERTEX_COUNT-1)];

     //generaete terrain 

        int vertexPointer = 0;
        for(int i=0;i<VERTEX_COUNT;i++){
            for(int j=0;j<VERTEX_COUNT;j++){
                vertices[vertexPointer*3] = (float)j/((float)VERTEX_COUNT - 1) * SIZE;
                vertices[vertexPointer*3+1] = 0;
                vertices[vertexPointer*3+2] = (float)i/((float)VERTEX_COUNT - 1) * SIZE;
                vertexPointer++;
            }
        }
        int pointer = 0;
        for(int gz=0;gz<VERTEX_COUNT-1;gz++){
            for(int gx=0;gx<VERTEX_COUNT-1;gx++){
                int topLeft = (gz*VERTEX_COUNT)+gx;
                int topRight = topLeft + 1;
                int bottomLeft = ((gz+1)*VERTEX_COUNT)+gx;
                int bottomRight = bottomLeft + 1;
                indices[pointer++] = topLeft;
                indices[pointer++] = bottomLeft;
                indices[pointer++] = topRight;
                indices[pointer++] = topRight;
                indices[pointer++] = bottomLeft;
                indices[pointer++] = bottomRight;
            }
        }

    //end generate terrain
        FloatBuffer buffer = BufferUtils.createFloatBuffer(vertices.length);
        buffer.put(vertices);
        buffer.flip();
        count = indices.length ;
         vid = GL15.glGenBuffers();
         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vid);
         GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);

         iid = GL15.glGenBuffers();
         GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, iid);
         IntBuffer indbuf = BufferUtils.createIntBuffer(indices.length);
         indbuf.put(indices);
         indbuf.flip();
         GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indbuf, GL15.GL_STATIC_DRAW);
         GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);

    }

    public void createprojection()
    {
        float aspect = (float) 1920/1080;
        float y_scale = (float) (1/Math.tan(Math.toRadians(fov/2f)));
        float x_scale = y_scale / aspect;
        float frustum_length = far - near;
        projectionmatrix.m00 = x_scale;
        projectionmatrix.m11 = y_scale;
        projectionmatrix.m22 = -((far + near) / frustum_length);
        projectionmatrix.m23 = -1;
        projectionmatrix.m32 = -((2 * near * far) / frustum_length);
        projectionmatrix.m33 = 0;
    }
    public void createview()
    {
        Vector3f modelPos = null;
        Vector3f modelAngle = null;
        Vector3f modelScale = null;
        Vector3f camera = new Vector3f(0,1f,-2f);
        modelPos = new Vector3f(0,0,0);
        modelAngle = new Vector3f(0,0,0);
        modelScale = new Vector3f(1, 1, 1);

        modelMatrix.setIdentity();
        Matrix4f.scale(modelScale, modelMatrix, modelMatrix);
        Matrix4f.translate(modelPos, modelMatrix, modelMatrix);
        Matrix4f.rotate((float) Math.toRadians(modelAngle.z), new Vector3f(0, 0, 1), 
                modelMatrix, modelMatrix);
        Matrix4f.rotate((float) Math.toRadians(modelAngle.y), new Vector3f(0, 1, 0), 
                modelMatrix, modelMatrix);
        Matrix4f.rotate((float) Math.toRadians(modelAngle.x), new Vector3f(1, 0, 0), 
                modelMatrix, modelMatrix);

            Matrix4f.translate(camera, view, view);


    }

    public void loadtoshader()
    {
        int loc1 = glGetUniformLocation(program, "projection"); 
        FloatBuffer matrixx  = BufferUtils.createFloatBuffer(16);
        projectionmatrix.store(matrixx);
        matrixx.flip();
            glUniformMatrix4fv(loc1, false,matrixx);
            int loc2 = glGetUniformLocation(program, "view"); 
            FloatBuffer matrixx2  = BufferUtils.createFloatBuffer(16);
            view.store(matrixx2);
            matrixx2.flip();
            glUniformMatrix4fv(loc2, false,matrixx2);

                int loc3 = glGetUniformLocation(program, "model"); 
                FloatBuffer matrixx3  = BufferUtils.createFloatBuffer(16);
                modelMatrix.store(matrixx3);
                matrixx3.flip();
                glUniformMatrix4fv(loc3, false,matrixx3);
    }



}



class mouse extends GLFWCursorPosCallback
{
    @Override
    public void invoke(long arg0, double x, double y) {
        // TODO Auto-generated method stub
    System.out.println(x+ " "+ y );
    }
}

大家好！我想在lwjgl中生成一个简单的平坦地形，但此代码不会给我带来任何影响。我在本章中是非常新的，因此，如果您可以解释为什么此代码无能为力，请这样做！我正在用Thinmatrix共享的代码生成地形，然后将顶点上传到缓冲区，然后将其渲染到主游戏循环中。当我编译时，它向我展示了一个黑屏。我搜索了很多教程，但没有找到可以帮助我的任何东西。

Answer 1

我看到了您的代码几个问题：

问题编号1：您将在循环的每个迭代中生成man类的新实例。创建循环外部对象的一个实例并将其在循环中使用。

第2期：您正在使用旧的静态管道OpenGL。在ThinMatrix的教程之后，您应该使用OpenGL 3或更新。一切都应该通过着色器，而不是使用 GL_PROJECTION_MATRIX及其。

您的程序应该看起来如下：

man instance = new man() while (!glfwWindowShouldClose(window)) { RENDER THE TERRAIN HERE glfwPoll glfwSwapBuffers glClear }

如果您想要一些示例代码，我在这里有一个存储库，就像我过去观看Thinmatrix教程一样。

编辑：解决方案

顶点着色器代码应该阅读：

gl_Position = projection * view * model * position;

Answer 2

我的着色器：fragment

    #version 330
in vec4 pos;
void main()
{
    gl_FragColor = vec4 (pos);
}

顶点：

    #version 330
attribute vec3 postion;
uniform mat4 projection;

uniform mat4 view;
uniform mat4 model;
out vec4 pos;
void main()
{
    gl_Position = vec4(postion, 1.0) * projection * view * model;
    pos =  vec4(postion, 1.0) ;
}

我已经更新了我的Java代码，因此它使不同的颜色基于顶点位置。