Quadrat in OpenGL nicht gerendert ⇐ Java

[Anonymous]

Ich bin ziemlich neu in der Grafik und ich versuche, ein einfaches Spiel in Java mit LWJGL und OpenGL zu programmieren, aber ich kann kein Quadrat zum Fenster rendern. Kann jemand helfen? Verwenden Sie ES-, Core- oder Kompatibilität
Fehler: 0: 1: '#Version': Bad Token folge Profil - erwartete neue Leitung
Fehler: 0: 1: '' Kein Code generiert. < /P>
Fehler: Fragment -Shader -Kompilierung fehlgeschlagen. Verwenden Sie ES-, Core- oder Kompatibilität
Fehler: 0: 1: '#Version': Bad Token folge Profil - erwartete neue Leitung
Fehler: 0: 1: '' Kein Code generiert. < /P>
Fehler: Verknüpfung von Shadern fehlgeschlagen.

Code: Select all

import java.nio.FloatBuffer;
import java.nio.IntBuffer;

import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;

public class Render {
private Shader shader;

private float[] vertexArray = {
0.5f, -0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
-0.5f, -0.5f, 0.0f
};

private int[] elementArray = {
2, 1, 0,
0, 1, 3
};

private int vaoID, vboID, eboID;

public Render() {
this.shader = new Shader("defaultVertexShader.glsl", "defaultFragmentShader.glsl", "src/main/resources/render/shaders/");
}

public void init() {
shader.compile();
shader.link();

vaoID = glGenVertexArrays();
glBindVertexArray(vaoID);

FloatBuffer vertexBuffer = BufferUtils.createFloatBuffer(vertexArray.length);
vertexBuffer.put(vertexArray).flip();

vboID = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, vboID);
glBufferData(GL_ARRAY_BUFFER, vertexBuffer, vboID);

IntBuffer elementBuffer = BufferUtils.createIntBuffer(elementArray.length);
elementBuffer.put(elementArray).flip();

eboID = glGenBuffers();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, eboID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBuffer, eboID);

glVertexAttribPointer(0, 3, GL_FLOAT, false, 12, 0);
glEnableVertexAttribArray(0);
}

public void render() {
shader.use();
glBindVertexArray(vaoID);
glEnableVertexAttribArray(0);

glDrawElements(GL_TRIANGLES, elementArray.length, GL_UNSIGNED_INT, 0);

glDisableVertexAttribArray(0);
glBindVertexArray(0);
shader.detach();
}
}
< /code>
Shader -Klasse < /p>
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

import static org.lwjgl.opengl.GL11.GL_FALSE;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL20.glUseProgram;

public class Shader {
private String vertexShaderSrc;
private String fragmentShaderSrc;

private int vertexID, fragmentID, shaderProgram;

public Shader(String vertexShader, String fragmentShader, String root) {
this.vertexShaderSrc = getShader(vertexShader, root);
this.fragmentShaderSrc = getShader(fragmentShader, root);
}

public void compile() {
vertexID = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexID, vertexShaderSrc);
glCompileShader(vertexID);
int success = glGetShaderi(vertexID, GL_COMPILE_STATUS);
if (success == GL_FALSE) {
int len = glGetShaderi(vertexID, GL_INFO_LOG_LENGTH);
System.out.println("ERROR: Vertex shader compilation failed.");
System.out.println(glGetShaderInfoLog(vertexID, len));
}

fragmentID = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentID, fragmentShaderSrc);
glCompileShader(fragmentID);
success = glGetShaderi(fragmentID, GL_COMPILE_STATUS);
if (success == GL_FALSE) {
int len = glGetShaderi(fragmentID, GL_INFO_LOG_LENGTH);
System.out.println("ERROR: Fragment shader compilation failed.");
System.out.println(glGetShaderInfoLog(fragmentID, len));
}
}

public void link() {
shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexID);
glAttachShader(shaderProgram, fragmentID);
glLinkProgram(shaderProgram);
int success = glGetProgrami(shaderProgram, GL_LINK_STATUS);
if (success == GL_FALSE) {
int len = glGetProgrami(shaderProgram, GL_INFO_LOG_LENGTH);
System.out.println("ERROR:  Linking of shaders failed.");
System.out.println(glGetProgramInfoLog(shaderProgram, len));
}
}

public void use() {
glUseProgram(shaderProgram);
}

public void detach() {
glUseProgram(0);
}

private String getShader(String shaderName, String root) {
String data = "";
File shaderFile = new File(root + shaderName);

try (Scanner reader = new Scanner(shaderFile)) {
while (reader.hasNextLine()) {
data += reader.nextLine();
}
} catch (FileNotFoundException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}

return data;
}
}
< /code>
Vertex -Shader < /p>
#version 330 core

layout (location=0) in vec3 pos;

void main() {
gl_Position = vec4(pos, 1.0f);
}
< /code>
Fragment Shader < /p>
#version 330 core

out vec4 color;

void main() {
color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}
< /code>
Fenster < /p>
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.opengl.GL;

import static org.lwjgl.glfw.Callbacks.glfwFreeCallbacks;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.system.MemoryUtil.NULL;

public class Window {
private static Window instance;

private int width, height;
private String title;
private long window;

private Window(int width, int height, String title) {
this.width = width;
this.height = height;
this.title = title;
}

public static Window get(int width, int height, String title) {
if (instance == null) instance = new Window(width, height, title);

return instance;
}

public void init() {
GLFWErrorCallback.createPrint(System.err).set();

if (!glfwInit()) throw new IllegalStateException("Unable to initialize GLFW");

glfwDefaultWindowHints();
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);

window = glfwCreateWindow(width, height, title, NULL, NULL);
if (window == NULL) throw new RuntimeException("Failed to create the GLFW window");

glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwShowWindow(window);

GL.createCapabilities();
}

public void destroy() {
glfwFreeCallbacks(window);
glfwDestroyWindow(window);

glfwTerminate();
glfwSetErrorCallback(null).free();
}

public long getWindow() {
return window;
}
}