Rewrote the base system, added entities, added matrices and textures.

Author: Edelkrebs

bin/me/finnthehumanlol/lwjgl/engine/Engine$1.class

@@ -4,7 +4,10 @@ in vec3 position;
 
 out vec3 color;
 
+uniform mat4 transformMatrix;
+uniform mat4 projectionMatrix;
+
 void main(void){
-	gl_Position = vec4(position.xyz, 1.0f);
+	gl_Position = projectionMatrix * transformMatrix * vec4(position.xyz, 1.0f);
 	color = vec3(1.0f, 0.0f, 1.0f);
 }

bin/me/finnthehumanlol/lwjgl/engine/Engine.class

@@ -1,24 +1,41 @@
 package me.finnthehumanlol.lwjgl.engine;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.lwjgl.glfw.GLFW;
 
 import me.finnthehumanlol.lwjgl.engine.core.MainGameLoop;
+import me.finnthehumanlol.lwjgl.engine.core.Updateable;
 import me.finnthehumanlol.lwjgl.engine.io.Window;
+import me.finnthehumanlol.lwjgl.engine.render.Renderer;
+import me.finnthehumanlol.lwjgl.engine.render.Shader;
+import me.finnthehumanlol.lwjgl.engine.types.builtin.Entity;
+import me.finnthehumanlol.lwjgl.engine.util.MathUtil;
 
 public final class Engine {
 
 	public static MainGameLoop mainGameLoop;
 	private static Window window;
+	private static List<Entity> entities = new ArrayList<Entity>();
 
 	public static Thread mainThread = new Thread(new Runnable() {
 
 		@Override
 		public void run() {
+			Renderer.projectionMatrix = MathUtil.createProjectionMatrix(Renderer.FOV, Renderer.MIN_DIST, Renderer.MAX_DIST);
+			Shader.projectionMatrix = Renderer.projectionMatrix;
 			mainGameLoop.start();
 			while(!GLFW.glfwWindowShouldClose(window.getWindow())) {				
-				mainGameLoop.update();
+				mainGameLoop.onUpdate();
+				for(Entity e : entities) {
+					e.onUpdate();
+				}
 				window.onRender();
-				mainGameLoop.render();
+				mainGameLoop.onRender();
+				for(Entity e : entities) {
+					e.onRender();
+				}
 				GLFW.glfwSwapBuffers(window.getWindow());
 			}
 			mainGameLoop.stop();
@@ -46,4 +63,8 @@ public static Thread getMainThread() {
 		return mainThread;
 	}
 
+	public static void addEntity(Entity e) {
+		Engine.entities.add(e);
+	}
+	
 }

bin/me/finnthehumanlol/lwjgl/engine/core/MainGameLoop.class

@@ -1,10 +1,8 @@
 package me.finnthehumanlol.lwjgl.engine.core;
 
-public interface MainGameLoop {
+public interface MainGameLoop extends Updateable{
 
 	public void start();
-	public void update();
-	public void render();
 	public void stop();
 
 }

bin/me/finnthehumanlol/lwjgl/engine/render/Renderer.class

@@ -1,11 +1,25 @@
 package me.finnthehumanlol.lwjgl.engine.render;
 
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
 import org.lwjgl.opengl.GL11;
 
 import me.finnthehumanlol.lwjgl.engine.types.Mesh;
+import me.finnthehumanlol.lwjgl.engine.types.builtin.Entity;
+import me.finnthehumanlol.lwjgl.engine.util.MathUtil;
 
 public class Renderer {
 
+	public static float FOV = 70;
+	public static float MIN_DIST = 0.1f;
+	public static float MAX_DIST = 1000;
+	
+	public static Matrix4f projectionMatrix;
+	
+	public static void updateProjectionMatrix() {
+		Renderer.projectionMatrix = MathUtil.createProjectionMatrix(FOV, MIN_DIST, MAX_DIST);
+	}
+	
 	public static void render(Mesh mesh) {
 		mesh.prepareRender();
 		if(mesh.getIbo() == 0)
@@ -16,6 +30,19 @@ public static void render(Mesh mesh) {
 		mesh.finishRender();
 	}
 
+	public static void render(Entity entity) {
+		entity.getMesh().prepareRender();
+		Matrix4f mat4 = MathUtil.createTransformationMatrix(entity.getPosition(), entity.getRotation(), new Vector3f(entity.getScale(), entity.getScale(), entity.getScale()));
+		entity.getMesh().getShader().setUniformMat4("transformMatrix", mat4);
+		entity.getMesh().getShader().setUniformMat4("projectionMatrix", Renderer.projectionMatrix);
+		if(entity.getMesh().getIbo() == 0)
+			GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, entity.getMesh().getVertexCount());
+		else {
+			GL11.glDrawElements(GL11.GL_TRIANGLES, entity.getMesh().getVertexCount(), GL11.GL_UNSIGNED_INT, 0);
+		}
+		entity.getMesh().finishRender();
+	}
+	
 	private Renderer() {}
 
 }

bin/me/finnthehumanlol/lwjgl/engine/render/Shader.class

@@ -4,14 +4,22 @@
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
+import java.nio.FloatBuffer;
 
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL20;
 
 public class Shader {
 
 	private String vertexPath, fragmentPath;
 
 	private int program, vertexShader, fragmentShader;
+	
+	public FloatBuffer matrixBuffer = BufferUtils.createFloatBuffer(16);
+	
+	public static Matrix4f projectionMatrix;
 
 	public Shader(String vertexPath, String fragmentPath) {
 		program = GL20.glCreateProgram();
@@ -25,9 +33,29 @@ public Shader(String vertexPath, String fragmentPath) {
 		GL20.glAttachShader(program, fragmentShader);
 		GL20.glLinkProgram(program);
 		GL20.glValidateProgram(program);
-
+		
+	}
+	
+	public int getUniformLocation(String variableName) {
+		return GL20.glGetUniformLocation(program, variableName);
+	}
+	
+	public void setUniform1i(String variableName, int value) {
+		GL20.glUniform1i(getUniformLocation(variableName), value);
+	}
+	
+	public void setUniform1f(String variableName, float value) {
+		GL20.glUniform1f(getUniformLocation(variableName), value);
+	}
+	
+	public void setUniformVec3(String variableName, Vector3f value) {
+		GL20.glUniform3f(getUniformLocation(variableName), value.x, value.y, value.z);
 	}
 
+	public void setUniformMat4(String variableName, Matrix4f value) {
+		GL20.glUniformMatrix4fv(getUniformLocation(variableName), false, value.get(matrixBuffer));
+	}
+	
 	public void bindAttribute(int index, String varName) {
 		GL20.glBindAttribLocation(program, index, varName);
 	}

bin/me/finnthehumanlol/lwjgl/engine/shaders/defaultVs.glsl

@@ -0,0 +1,11 @@
+#version 400 core
+
+in vec2 outTexCoord;
+
+out vec4 color;
+
+uniform sampler2D textureSampler;
+
+void main(void){
+	color = texture(textureSampler, outTexCoord);
+}

bin/me/finnthehumanlol/lwjgl/engine/types/Mesh.class

@@ -0,0 +1,14 @@
+#version 400 core
+
+in vec3 position;
+in vec2 texCoord;
+
+out vec2 outTexCoord;
+
+uniform mat4 transformMatrix;
+uniform mat4 projectionMatrix;
+
+void main(void){
+	gl_Position = projectionMatrix * transformMatrix * vec4(position.xyz, 1.0f);
+	outTexCoord = texCoord;
+}

bin/me/finnthehumanlol/lwjgl/engine/types/Texture.class

@@ -4,7 +4,10 @@ in vec3 position;
 
 out vec3 color;
 
+uniform mat4 transformMatrix;
+uniform mat4 projectionMatrix;
+
 void main(void){
-	gl_Position = vec4(position.xyz, 1.0f);
+	gl_Position = projectionMatrix * transformMatrix * vec4(position.xyz, 1.0f);
 	color = vec3(1.0f, 0.0f, 1.0f);
 }

bin/me/finnthehumanlol/lwjgl/project/Main.class

@@ -3,6 +3,8 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL15;
 import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL30;
@@ -14,8 +16,9 @@ public class Mesh {
 	private int vao, vertexCount, attributeCount;
 	private int ibo = 0;
 	private Shader shader;
-	private float[] positions;
+	private float[] positions, texCoords;
 	private int[] indices;
+	private Texture texture;
 
 	private List<Integer> vbos = new ArrayList<>();
 
@@ -25,6 +28,7 @@ public Mesh(float[] positions) {
 		vertexCount = positions.length / 3;
 		GL30.glBindVertexArray(vao);
 		addAttribute(0, positions, 3);
+		attachShader();
 	}
 
 	public Mesh(float[] positions, int[] indices) {
@@ -34,39 +38,66 @@ public Mesh(float[] positions, int[] indices) {
 		vertexCount = indices.length;
 		GL30.glBindVertexArray(vao);
 		addAttribute(0, positions, 3);
+		addIndexBuffer(indices);
+		attachShader();
 	}
 
+	public void applyTexture(Texture texture, float[] texCoords) {
+		this.texture = texture;
+		this.shader = new Shader("src/me/finnthehumanlol/lwjgl/engine/shaders/defaultTexVs.glsl", "src/me/finnthehumanlol/lwjgl/engine/shaders/defaultTexFs.glsl");
+		this.texCoords = texCoords;
+		addAttribute(1, texCoords, 2);
+	}
+	
+	public void applyTexture(Texture texture, float[] texCoords, Shader texShader) {
+		this.texture = texture;
+		this.shader = texShader;
+		this.texCoords = texCoords;
+	}
+	
 	public void attachShader(Shader shader) {
 		this.shader = shader;
 	}
 
 	public void attachShader() {
-		this.shader = new Shader("src/me/finnthehumanlol/lwjgl/engine/shaders/defaultFs.glsl", "src/me/finnthehumanlol/lwjgl/engine/shaders/defaultVs.glsl");
+		this.shader = new Shader("src/me/finnthehumanlol/lwjgl/engine/shaders/defaultVs.glsl", "src/me/finnthehumanlol/lwjgl/engine/shaders/defaultFs.glsl");
 	}
 
 	public void detachShader() {
-		this.shader = null;
+		this.shader = new Shader("src/me/finnthehumanlol/lwjgl/engine/shaders/defaultVs.glsl", "src/me/finnthehumanlol/lwjgl/engine/shaders/defaultFs.glsl");
 	}
 
 	public void prepareRender() {
 		GL30.glBindVertexArray(vao);
 
-		for (int i = 0; i < attributeCount; i++)
-			GL20.glEnableVertexAttribArray(i);
-		if(shader != null) {
-			GL20.glUseProgram(shader.getProgram());
-		}
+		GL20.glEnableVertexAttribArray(0);
+
+		GL20.glEnableVertexAttribArray(1);
+		
+		GL20.glUseProgram(shader.getProgram());
 
 		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, ibo);
+		
+		if(texture != null) {			
+			GL13.glActiveTexture(GL13.GL_TEXTURE0);
+			GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture.getTextureID());
+		}
 	}
 
 	public void finishRender() {
 		GL30.glBindVertexArray(0);
-		for (int i = 0; i < attributeCount; i++)
-			GL20.glDisableVertexAttribArray(i);
+		
+		GL20.glDisableVertexAttribArray(0);
+		GL20.glDisableVertexAttribArray(1);
+		
 		GL20.glUseProgram(0);
 
 		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+		
+		if(texture != null) {
+			GL13.glActiveTexture(0);
+			GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+		}
 	}
 
 	private void addIndexBuffer(int[] data) {
@@ -116,4 +147,16 @@ public Shader getShader() {
 		return shader;
 	}
 
+	public float[] getPositions() {
+		return positions;
+	}
+
+	public int[] getIndices() {
+		return indices;
+	}
+
+	public Texture getTexture() {
+		return texture;
+	}
+
 }

hs_err_pid10904.log

@@ -29,24 +29,25 @@ public Texture(String texturePath) {
 			IntBuffer w = stack.mallocInt(1);
 			IntBuffer h = stack.mallocInt(1);
 			IntBuffer comp = stack.mallocInt(1);
-		
+			
 			image = STBImage.stbi_load(texturePath, w, h, comp, 4);
 
 			if(image == null) {
-				System.err.println("Couldnt load texture!");
+				System.err.println("Image could not be read:" + texturePath);
 			}
 
 			width = w.get();
 			height = h.get();
 			this.texWidth = width;
 			this.texHeight = height;
-			
 		}
 
 		textureID = GL11.glGenTextures();
 		GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
 		GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
 		GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
+		GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
+		GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
 		GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, image);
 		GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);