在LWJGL 3中使用VAOs和VBOs渲染四边形时出现问题。

huangapple
go评论102阅读模式
英文:

Problem with rendering a quad in LWJGL 3 using VAOs and VBOs

问题

以下是您提供的代码的翻译部分：

  1. public class RawModel {
  2.     private int vaoID;
  3.     private int vertexCount;
  4.      
  5.     public RawModel(int vaoID, int vertexCount) {
  6.         this.vaoID = vaoID;
  7.         this.vertexCount = vertexCount;
  8.     }
  9.  
  10.     public int getVaoID() {
  11.         return vaoID;
  12.     }
  13.  
  14.     public int getVertexCount() {
  15.         return vertexCount;
  16.     }
  17. }
  19. public class Loader {
  20.         
  21.     private List<Integer> vaos = new ArrayList<Integer>();
  22.     private List<Integer> vbos = new ArrayList<Integer>();
  23.      
  24.     public RawModel loadToVAO(float[] positions) {
  25.         int vaoID = createVAO();
  26.         storeDataInAttributeList(0, positions);
  27.         unbindVAO();
  28.         return new RawModel(vaoID, positions.length/3);
  29.     }
  30.      
  31.     private int createVAO() {
  32.         int vaoID = GL30.glGenVertexArrays();
  33.         vaos.add(vaoID);
  34.         GL30.glBindVertexArray(vaoID);
  35.         return vaoID;
  36.     }
  37.      
  38.     private void storeDataInAttributeList(int attributeNumber, float[] data) {
  39.         int vboID = GL15.glGenBuffers();
  40.         vbos.add(vboID);
  41.         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboID);
  42.         FloatBuffer buffer = storeDataInFloatBuffer(data);
  43.         GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
  44.         GL20.glVertexAttribPointer(attributeNumber, 3, GL11.GL_FLOAT, false, 0, 0);
  45.         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
  46.     }
  47.      
  48.     private void unbindVAO() {
  49.         GL30.glBindVertexArray(0);
  50.     }
  51.      
  52.     private FloatBuffer storeDataInFloatBuffer(float[] data) {
  53.         FloatBuffer buffer = MemoryUtil.memAllocFloat(data.length);
  54.         buffer.put(data);
  55.         buffer.flip();
  56.         return buffer;
  57.     }
  58.      
  59.     public void cleanUp() {
  60.         for (int vao : vaos) {
  61.             GL30.glDeleteVertexArrays(vao);
  62.         }
  63.         for (int vbo : vbos) {
  64.             GL15.glDeleteBuffers(vbo);
  65.         }
  66.     }
  67. }
  69. public class Renderer {
  71.     public void prepare() {
  72.         GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
  73.         GL11.glClearColor(1f, 0f, 1f, 1f);
  74.     }
  75.      
  76.     public void render(RawModel model) {
  77.         GL30.glBindVertexArray(model.getVaoID());
  78.         GL20.glEnableVertexAttribArray(0);
  79.         GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, model.getVertexCount());
  80.         GL20.glDisableVertexAttribArray(0);
  81.         GL30.glBindVertexArray(0);
  82.     }
  83. }
  85. public class Window {
  86.     private int width, height;
  87.     private String title;
  88.     private long window;
  89.  
  90.     public Window(int width, int height, String title) {
  91.         this.width = width;
  92.         this.height = height;
  93.         this.title = title;
  94.     }
  95.  
  96.     public void create() {
  97.         GLFWErrorCallback.createPrint(System.err).set();
  98.  
  99.         if (!glfwInit())
  100.             throw new IllegalStateException("Unable to initialize GLFW");
  101.  
  102.         glfwDefaultWindowHints();
  103.         glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
  104.         glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
  105.  
  106.         window = glfwCreateWindow(width, height, "Flappy Bird", NULL, NULL);
  107.         if (window == NULL)
  108.             throw new RuntimeException("Failed to create the GLFW window");
  109.  
  110.         try (MemoryStack stack = stackPush()) {
  111.             IntBuffer pWidth = stack.mallocInt(1);
  112.             IntBuffer pHeight = stack.mallocInt(1);
  113.  
  114.             glfwGetWindowSize(window, pWidth, pHeight);
  115.  
  116.             GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
  117.  
  118.             glfwSetWindowPos(window, (vidmode.width() - pWidth.get(0)) / 2, (vidmode.height() - pHeight.get(0)) / 2);
  119.         }
  120.          
  121.         glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> {
  122.             if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
  123.                 glfwSetWindowShouldClose(window, true);
  124.         });
  125.  
  126.         glfwMakeContextCurrent(window);
  127.         glfwSwapInterval(1);
  128.  
  129.         glfwShowWindow(window);
  130.     }
  131.  
  132.     public long getWindowNum() {
  133.         return window;
  134.     }
  135. }
  137. public class Main {
  138.  
  139.     private Window window;
  140.      
  141.     Loader loader = new Loader();
  142.     Renderer renderer = new Renderer();
  143.      
  144.     float[] vertices = {
  145.         -0.5f, 0.5f, 0f,
  146.         -0.5f, -0.5f, 0f,
  147.         0.5f, -0.5f, 0f,
  148.         0.5f, -0.5f, 0f,
  149.         0.5f, 0.5f, 0f,
  150.         -0.5f, 0.5f, 0f
  151.     };
  152.      
  153.     RawModel model;
  154.      
  155.     public void run() {
  156.         setup();
  157.         loop();
  158.          
  159.         loader.cleanUp();
  160.  
  161.         glfwFreeCallbacks(window.getWindowNum());
  162.         glfwDestroyWindow(window.getWindowNum());
  163.          
  164.         glfwTerminate();
  165.         glfwSetErrorCallback(null).free();
  166.     }
  167.  
  168.     private void loop() {
  169.         while (!glfwWindowShouldClose(window.getWindowNum())) {
  170.             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  171.              
  172.             renderer.render(model);
  173.              
  174.             glfwSwapBuffers(window.getWindowNum());
  175.              
  176.             glfwPollEvents();
  177.         }
  178.     }
  179.  
  180.     public void setup() {
  181.         window = new Window(900, 300, "Flappy Bird");
  182.         window.create();
  183.          
  184.         GL.createCapabilities();
  185.         GLFW.glfwMakeContextCurrent(window.getWindowNum());
  186.  
  187.         model = loader.loadToVAO(vertices);
  188.         renderer.prepare();
  189.          
  190.         GL11.glViewport(0, 0, 900, 300);
  191.     }
  192.      
  193.     public static void main(String[] args) {
  194.         new Main().run();
  195.     }
  196. }
英文:

(This is the second time I am asking this question. Last time I got one answer that didn't solve it (the answer there referred a bit of code that was left accidentally from one of my attempts at fixing this). I also changed the question itself slightly - I changed the order of code to put the part where I believe the mistake higher is and added that I am using macOS, which might be the reason that it doesn't work).

So, I just started learning LWJGL 3 and I used a mixture of a couple of tutorials and example code to make something that should render a rectangle to a magenta screen using VAOs and VBOs. There are no errors but the rectangle doesn't appear on screen (all I can see is a magenta screen). I tried using the old LWJGL pipeline (glBegin() and glEnd()) and it does work so I tried changing random things in the rendering code and the loading to VAOs and VBOs. I also tried to bind the VBO too but it didn't change anything. I also tried debugging and it seems like there is a VAO and a VBO that is created.

Can someone take a look at my code and see if something looks wrong? Here it is (sorry if its a bit messy. Like I said, I don't think the problem is in the Main or Window class but I have no idea about LWJGL so I wanted to put it here anyways. If you have time, please also look at them. Otherwise I would really appreciate it if you could look at the Loader and Renderer classes):

(Btw, I am using macOS, and I do have -XstartOnFirstThread on).

The Raw Model class:

  1. package engine.io;
  2.  
  3. public class RawModel {
  4.     private int vaoID;
  5.     private int vertexCount;
  6.      
  7.     public RawModel(int vaoID, int vertexCount) {
  8.         this.vaoID = vaoID;
  9.         this.vertexCount = vertexCount;
  10.     }
  11.  
  12.     public int getVaoID() {
  13.         return vaoID;
  14.     }
  15.  
  16.     public int getVertexCount() {
  17.         return vertexCount;
  18.     }
  19. }

The loader class:

  1. package engine.io;
  2.  
  3. import java.nio.FloatBuffer;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import org.lwjgl.BufferUtils;
  8. import org.lwjgl.opengl.GL11;
  9. import org.lwjgl.opengl.GL15;
  10. import org.lwjgl.opengl.GL20;
  11. import org.lwjgl.opengl.GL30;
  12. import org.lwjgl.system.MemoryUtil;
  14. public class Loader {
  15.         
  16.     private List&lt;Integer&gt; vaos = new ArrayList&lt;Integer&gt;();
  17.     private List&lt;Integer&gt; vbos = new ArrayList&lt;Integer&gt;();
  18.      
  19.     public RawModel loadToVAO(float[] positions) {
  20.         int vaoID = createVAO();
  21.         storeDataInAttributeList(0, positions);
  22.         unbindVAO();
  23.         return new RawModel(vaoID, positions.length/3);
  24.     }
  25.      
  26.     private int createVAO() {
  27.         int vaoID = GL30.glGenVertexArrays();
  28.         vaos.add(vaoID);
  29.         GL30.glBindVertexArray(vaoID);
  30.         return vaoID;
  31.     }
  32.      
  33.     private void storeDataInAttributeList(int attributeNumber, float[] data) {
  34.         int vboID = GL15.glGenBuffers();
  35.         vbos.add(vboID);
  36.         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboID);
  37.         FloatBuffer buffer = storeDataInFloatBuffer(data);
  38.         GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
  39.         GL20.glVertexAttribPointer(attributeNumber, 3, GL11.GL_FLOAT, false, 0, 0);
  40.         GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
  41.     }
  42.      
  43.     private void unbindVAO() {
  44.         GL30.glBindVertexArray(0);
  45.     }
  46.      
  47.     private FloatBuffer storeDataInFloatBuffer(float[] data) {
  48.         FloatBuffer buffer = MemoryUtil.memAllocFloat(data.length);
  49.         buffer.put(data);
  50.         buffer.flip();
  51.         return buffer;
  52.     }
  53.      
  54.     public void cleanUp() {
  55.         for (int vao : vaos) {
  56.             GL30.glDeleteVertexArrays(vao);
  57.         }
  58.         for (int vbo : vbos) {
  59.             GL15.glDeleteBuffers(vbo);
  60.         }
  61.     }
  62. }

The renderer class:

  1. package engine.io;
  2.     
  3. import org.lwjgl.opengl.GL11;
  4. import org.lwjgl.opengl.GL15;
  5. import org.lwjgl.opengl.GL20;
  6. import org.lwjgl.opengl.GL30;
  8. public class Renderer {
  10.     public void prepare() {
  11.         GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
  12.         GL11.glClearColor(1f, 0f, 1f, 1f);
  13.     }
  14.      
  15.     public void render(RawModel model) {
  16.         GL30.glBindVertexArray(model.getVaoID());
  17.         GL20.glEnableVertexAttribArray(0);
  18.         GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, model.getVertexCount());
  19.         GL20.glDisableVertexAttribArray(0);
  20.         GL30.glBindVertexArray(0);
  21.     }
  22. }

Here is the Main class:

  1. import org.lwjgl.*;
  2. import org.lwjgl.glfw.*;
  3. import org.lwjgl.opengl.*;
  4. import org.lwjgl.system.*;
  6. import engine.io.Loader;
  7. import engine.io.RawModel;
  8. import engine.io.Renderer;
  9. import engine.io.Window;
  11. import java.nio.*;
  13. import static org.lwjgl.glfw.Callbacks.*;
  14. import static org.lwjgl.glfw.GLFW.*;
  15. import static org.lwjgl.opengl.GL11.*;
  16. import static org.lwjgl.system.MemoryStack.*;
  17. import static org.lwjgl.system.MemoryUtil.*;
  19. public class Main {
  20.  
  21.     private Window window;
  22.      
  23.     Loader loader = new Loader();
  24.     Renderer renderer = new Renderer();
  25.      
  26.     float[] vertices = {
  27.             // Left bottom triangle
  28.             -0.5f, 0.5f, 0f,
  29.             -0.5f, -0.5f, 0f,
  30.             0.5f, -0.5f, 0f,
  31.             // Right top triangle
  32.             0.5f, -0.5f, 0f,
  33.             0.5f, 0.5f, 0f,
  34.             -0.5f, 0.5f, 0f
  35.     };
  36.      
  37.     RawModel model;
  38.      
  39.     public void run() {
  40.         setup();
  41.         loop();
  42.          
  43.         loader.cleanUp();
  44.  
  45.         glfwFreeCallbacks(window.getWindowNum());
  46.         glfwDestroyWindow(window.getWindowNum());
  47.          
  48.         glfwTerminate();
  49.         glfwSetErrorCallback(null).free();
  50.     }
  51.  
  52.     private void loop() {
  53.         while ( !glfwWindowShouldClose(window.getWindowNum()) ) {
  54.             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer
  55.              
  56.             renderer.render(model);
  57.              
  58.             glfwSwapBuffers(window.getWindowNum()); // swap the color buffers
  59.              
  60.             glfwPollEvents();
  61.         }
  62.     }
  63.  
  64.     public void setup() {
  65.         window = new Window(900, 300, &quot;Flappy Bird&quot;);
  66.         window.create();
  67.          
  68.         GL.createCapabilities();
  69.         GLFW.glfwMakeContextCurrent(window.getWindowNum());
  70.  
  71.         model = loader.loadToVAO(vertices);
  72.         renderer.prepare();
  73.          
  74.         GL11.glViewport(0, 0, 900, 300);
  75.         
  76.     }
  77.      
  78.     public static void main(String[] args) {
  79.         new Main().run();
  80.     }
  81. }

Here is the window class:

  1. package engine.io;
  2.  
  3. import static org.lwjgl.glfw.GLFW.*;
  4. import static org.lwjgl.opengl.GL11.*;
  5. import static org.lwjgl.system.MemoryStack.stackPush;
  6. import static org.lwjgl.system.MemoryUtil.*;
  8. import java.nio.IntBuffer;
  10. //import static org.lwjgl.glfw.GLFW.*;
  11. import org.lwjgl.glfw.GLFW;
  12. import org.lwjgl.glfw.GLFWErrorCallback;
  13. import org.lwjgl.glfw.GLFWVidMode;
  14. import org.lwjgl.system.MemoryStack;
  16. public class Window {
  17.     private int width, height;
  18.     private String title;
  19.     private long window;
  20.  
  21.     public Window(int width, int height, String title) {
  22.         this.width = width;
  23.         this.height = height;
  24.         this.title = title;
  25.     }
  26.  
  27.     public void create() {
  28.         GLFWErrorCallback.createPrint(System.err).set();
  29.  
  30.         if (!glfwInit())
  31.             throw new IllegalStateException(&quot;Unable to initialize GLFW&quot;);
  32.  
  33.         // Configure GLFW
  34.         glfwDefaultWindowHints(); // optional, the current window hints are already the default
  35.         glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
  36.         glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable
  37.  
  38.         // Create the window
  39.         window = glfwCreateWindow(width, height, &quot;Flappy Bird&quot;, NULL, NULL);
  40.         if (window == NULL)
  41.             throw new RuntimeException(&quot;Failed to create the GLFW window&quot;);
  42.  
  43.         // Get the thread stack and push a new frame
  44.         try (MemoryStack stack = stackPush()) {
  45.             IntBuffer pWidth = stack.mallocInt(1); // int*
  46.             IntBuffer pHeight = stack.mallocInt(1); // int*
  47.  
  48.             // Get the window size passed to glfwCreateWindow
  49.             glfwGetWindowSize(window, pWidth, pHeight);
  50.  
  51.             // Get the resolution of the primary monitor
  52.             GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
  53.  
  54.             // Center the window
  55.             glfwSetWindowPos(window, (vidmode.width() - pWidth.get(0)) / 2, (vidmode.height() - pHeight.get(0)) / 2);
  56.         } // the stack frame is popped automatically
  57.             // Setup a key callback. It will be called every time a key is pressed, repeated
  58.             // or released.
  59.         glfwSetKeyCallback(window, (window, key, scancode, action, mods) -&gt; {
  60.             if (key == GLFW_KEY_ESCAPE &amp;&amp; action == GLFW_RELEASE)
  61.                 glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop
  62.         });
  63.  
  64.         // Make the OpenGL context current
  65.         glfwMakeContextCurrent(window);
  66.         // Enable v-sync
  67.         glfwSwapInterval(1);
  68.  
  69.         // Make the window visible
  70.         glfwShowWindow(window);
  71.  
  72.     }
  73.          
  74.     public long getWindowNum() {
  75.         return window;
  76.     }
  77. }

答案1

得分: 2

由于您使用的是MacOS，我建议您设置一个3.2核心配置OpenGL上下文。请参阅在OS X上进行OpenGL开发：

  1. glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  2. glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  3. glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
  4. glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  6. // 创建窗口
  7. window = glfwCreateWindow(width, height, "Flappy Bird", NULL, NULL);
英文:

Since you are on MacOS, I recommend to set up a 3.2 core profile OpenGL Context. See OpenGL Development on OS X:

  1. glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  2. glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  3. glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
  4. glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  6. // Create the window
  7. window = glfwCreateWindow(width, height, &quot;Flappy Bird&quot;, NULL, NULL);

huangapple
  • 本文由 发表于 2020年8月23日 17:40:15
  • 转载请务必保留本文链接：https://go.coder-hub.com/63545503.html
  • java
  • lwjgl
  • opengl
  • vao
  • vbo
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定