Notes

package engineTester;

import org.lwjgl.opengl.Display;

import shaders.staticShader;
import gameEngine.Loading;
import gameEngine.Rendering;
import gameEngine.displayManager;
import gameEngine.rawModel;

public class mainGameLoop {
public static void main(String[] args) {

displayManager.createDisplay();

Loading loader = new Loading();
Rendering renderer = new Rendering();

staticShader shader = new staticShader();

float[] vertices = {
-0.5f, 0.5f, 0f,
-0.5f, -0.5f, 0f,
0.5f, -0.5f, 0f,
0.5f, 0.5f, 0f,
};

int[] indices = {
0,1,3, //top left triangle (V0,V1,V3)
3,1,2 //bottom right triangle (V3,V1,V2)
};

rawModel model = loader.loadToVAO(vertices,indices);

while(!Display.isCloseRequested()){
//gamelogic
renderer.prepare();
shader.start();
renderer.render(model);
shader.stop();
displayManager.updateDisplay();
}

shader.cleanUp();
loader.cleanUp();
displayManager.closeDisplay();

}
}
package gameEngine;

import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.ContextAttribs;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.PixelFormat;
public class displayManager {
private static final int WIDTH = 1280;
private static final int HEIGHT = 702;
private static final int fps_cap = 120;
private static final String newTitle = "Space";
public static void createDisplay(){
ContextAttribs attribs = new ContextAttribs(3,2).withForwardCompatible(true).withProfileCore(true);
try {
Display.setDisplayMode(new DisplayMode(WIDTH,HEIGHT));
Display.create(new PixelFormat(), attribs);
Display.setTitle(newTitle);
} catch (LWJGLException e) {
e.printStackTrace();
}
GL11.glViewport(0, 0, WIDTH, HEIGHT);
}
public static void updateDisplay(){
Display.sync(fps_cap);
Display.update();
}
public static void closeDisplay(){
Display.destroy();
}
}

package gameEngine;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.List;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;

public class Loading {

private List<Integer> vaos = new ArrayList<Integer>();
private List<Integer> vbos = new ArrayList<Integer>();


public rawModel loadToVAO(float[] positions,int[] indices){
int vaoID = createVAO();
bindIndicesBuffer(indices);
storeDataInAttributeList(0,positions);
unbindVAO();
return new rawModel(vaoID,indices.length);
}

public void cleanUp(){
for(int vao:vaos){
GL30.glDeleteVertexArrays(vao);
}
for(int vbo:vbos){
GL15.glDeleteBuffers(vbo);
}
}

private int createVAO(){

int vaoID = GL30.glGenVertexArrays();
vaos.add(vaoID);
GL30.glBindVertexArray(vaoID);
return vaoID;

}
private void storeDataInAttributeList(int attributeNumber, float[] data){
int vboID = GL15.glGenBuffers();
vbos.add(vboID);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboID);
FloatBuffer buffer = storeDataInFloatBuffer(data);
GL15.glBufferData(GL15.GL_ARRAY_BUFFER,buffer,GL15.GL_STATIC_DRAW);
GL20.glVertexAttribPointer(attributeNumber, 3, GL11.GL_FLOAT, false, 0,0);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
}

private void unbindVAO(){
GL30.glBindVertexArray(0);
}

private void bindIndicesBuffer(int[] indices){
int vboID = GL15.glGenBuffers();
vbos.add(vboID);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboID);
IntBuffer buffer = storeDataInIntBuffer(indices);
GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);

}

private IntBuffer storeDataInIntBuffer(int[] data){
IntBuffer buffer = BufferUtils.createIntBuffer(data.length);
buffer.put(data);
buffer.flip();
return buffer;
}

private FloatBuffer storeDataInFloatBuffer(float[] data){
FloatBuffer buffer = BufferUtils.createFloatBuffer(data.length);
buffer.put(data);
buffer.flip();
return buffer;
}
}
package gameEngine;
public class rawModel {
private int vaoID;
private int vertexCount;

public rawModel(int vaoID, int vertexCount) {
this.vaoID = vaoID;
this.vertexCount = vertexCount;
}

public int getVaoID() {
return vaoID;
}

public int getVertexCount() {
return vertexCount;
}
}

package gameEngine;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;

public class Rendering {

public void prepare(){
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
GL11.glClearColor(0, 1, 1, 1);

}

public void render(rawModel model){
GL30.glBindVertexArray(model.getVaoID());
GL20.glEnableVertexAttribArray(0);
GL11.glDrawElements(GL11.GL_TRIANGLES, model.getVertexCount(), GL11.GL_UNSIGNED_INT, 0);
GL20.glDisableVertexAttribArray(0);
GL30.glBindVertexArray(0);
}
}

#version 150

in vec3 colour;

out vec4 out_Color;

void main(void){

out_Color = vec4(colour,1.0);

}
package shaders;

public class staticShader extends shaderProgram{

private static final String VERTEX_FILE = "src/shaders/vertexShader.txt";
private static final String FRAGMENT_FILE = "src/shaders/fragmentShader.txt";

public staticShader(){
super(VERTEX_FILE, FRAGMENT_FILE);

}

@Override
protected void bindAttributes() {
super.bindAttribute(0, "position");
}
}
package shaders;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20;

public abstract class shaderProgram {

private int programID;
private int vertexShaderID;
private int fragmentShaderID;

public shaderProgram(String vertexFile,String fragmentFile){
vertexShaderID = loadShader(vertexFile,GL20.GL_VERTEX_SHADER);
fragmentShaderID = loadShader(fragmentFile,GL20.GL_FRAGMENT_SHADER);
programID = GL20.glCreateProgram();
GL20.glAttachShader(programID, vertexShaderID);
GL20.glAttachShader(programID, fragmentShaderID);
GL20.glLinkProgram(programID);
GL20.glValidateProgram(programID);

}

public void start(){
GL20.glUseProgram(programID);
}

public void stop(){
GL20.glUseProgram(0);
}

public void cleanUp(){
stop();
GL20.glDetachShader(programID, vertexShaderID);
GL20.glDetachShader(programID, fragmentShaderID);
GL20.glDeleteShader(vertexShaderID);
GL20.glDeleteShader(fragmentShaderID);
GL20.glDeleteProgram(programID);
}

protected abstract void bindAttributes();

protected void bindAttribute(int attribute, String variableName){
GL20.glBindAttribLocation(programID, attribute, variableName);
}

private static int loadShader(String file, int type){
StringBuilder shaderSource = new StringBuilder();
try{
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
while((line = reader.readLine())!=null){
shaderSource.append(line).append("//n");
}
reader.close();
}catch(IOException e){
e.printStackTrace();
System.exit(-1);
}
int shaderID = GL20.glCreateShader(type);
GL20.glShaderSource(shaderID, shaderSource);
GL20.glCompileShader(shaderID);
if(GL20.glGetShaderi(shaderID, GL20.GL_COMPILE_STATUS )== GL11.GL_FALSE){
System.out.println(GL20.glGetShaderInfoLog(shaderID, 500));
System.err.println("Could not compile shader!");
System.exit(-1);
}
return shaderID;
}
}
#version 400 core

in vec3 position;

out vec3 colour;

void main(void){

gl_Position = vec4(position.x,position.y,position.z,1);
colour = vec3(position.x+0.5,1.0,position.y+0.5);

}