Load OBJ models

client/pom.xml

@@ -100,11 +100,6 @@
             <artifactId>lwjgl</artifactId>
             <classifier>${lwjgl.natives}</classifier>
         </dependency>
-        <dependency>
-            <groupId>org.lwjgl</groupId>
-            <artifactId>lwjgl-assimp</artifactId>
-            <classifier>${lwjgl.natives}</classifier>
-        </dependency>
         <dependency>
             <groupId>org.lwjgl</groupId>
             <artifactId>lwjgl-bgfx</artifactId>

client/src/main/java/core/engine/Engine.java

@@ -112,24 +112,6 @@ public class Engine {
         // Set the clear color
         glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
         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,
-                3,1,2
-        };
-
-        float[] textureCoords = {
-                0,0, // V0
-                0,1, // V1
-                1,1, // V2
-                1,0  // V3
-
-        };
 
         Camera camera = new Camera();
         glfwSetKeyCallback(window, glfwKeyCallback = new GLFWKeyCallback() {
@@ -156,13 +138,14 @@ public class Engine {
         });
 
         Renderer renderer = new Renderer(shader);
-        RawModel model = loader.loadToVAO(vertices,textureCoords,  indices);
+        RawModel model = OBJLoader.loadOBJModel("stall", loader);
-        ModelTexture modelTexture = new ModelTexture(loader.loadTexture("test_texture"));
+        ModelTexture modelTexture = new ModelTexture(loader.loadTexture("stallTexture"));
         TexturedModel texturedModel = new TexturedModel(model, modelTexture);
-        Entity entity = new Entity(texturedModel, new Vector3f(-1,0,-1), 0,0,0,1);
+        Entity entity = new Entity(texturedModel, new Vector3f(0,0,-50), 0,0,0,1);
         // Run the rendering loop until the user has attempted to close
         // the window or has pressed the ESCAPE key.
         while ( !glfwWindowShouldClose(window) ) {
+            entity.increaseRotation(0,1,0);
             renderer.prepare();
             shader.start();
             shader.loadViewMatrix(camera);

client/src/main/java/core/engine/Loader.java

@@ -29,7 +29,7 @@ public class Loader {
     }
 
     public int loadTexture(String fileName) {
-        Texture texture = new Texture("res/textures/" + fileName + ".png");
+        Texture texture = new Texture("res/" + fileName + ".png");
         int textureID = texture.getTextureID();
         this.textureIDs.add(textureID);
         return textureID;

client/src/main/java/core/engine/OBJLoader.java

@@ -0,0 +1,119 @@
+package core.engine;
+
+import core.engine.model.RawModel;
+import utils.vectors.Vector2f;
+import utils.vectors.Vector3f;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.List;
+
+public class OBJLoader {
+
+    public static RawModel loadOBJModel(String fileName, Loader loader) {
+        FileReader fileReader = null;
+        try {
+            fileReader = new FileReader("res/" + fileName + ".obj");
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        if(fileReader != null) {
+            BufferedReader bufferedReader = new BufferedReader(fileReader);
+            String line = null;
+            List<Vector3f> vertices = new ArrayList<>();
+            List<Vector2f> textures = new ArrayList<>();
+            List<Vector3f> normals = new ArrayList<>();
+            List<Integer> indices = new ArrayList<>();
+
+            float[] verticesArray = null;
+            float[] normalsArray = null;
+            float[] texturesArray = null;
+            int[] indicesArray = null;
+
+            try {
+                while(bufferedReader.ready()) {
+                    line = bufferedReader.readLine();
+                    String[] splittedLine = line.split(" ");
+                    if(splittedLine[0].equals("v")) {
+                        Vector3f vertex = new Vector3f(Float.parseFloat(splittedLine[1]),
+                                Float.parseFloat(splittedLine[2]), Float.parseFloat(splittedLine[3]));
+                        vertices.add(vertex);
+                    } else if(splittedLine[0].equals("vt")) {
+                        Vector2f texture = new Vector2f(Float.parseFloat(splittedLine[1]), Float.parseFloat(splittedLine[2]));
+                        textures.add(texture);
+                    } else if(splittedLine[0].equals("vn")) {
+                        Vector3f normal = new Vector3f(Float.parseFloat(splittedLine[1]),
+                                Float.parseFloat(splittedLine[2]), Float.parseFloat(splittedLine[3]));
+                        normals.add(normal);
+                    } else if(splittedLine[0].equals("f")) {
+                        //No more vertices/textures/normals should be added at this point in the file
+                        texturesArray = new float[vertices.size()*2];
+                        normalsArray = new float[vertices.size()*3];
+                        break;
+                    }
+                }
+
+                while(line != null) {
+                    if(!line.startsWith("f ")) {
+                        line = bufferedReader.readLine();
+                        continue;
+                    }
+
+                    String[] splittedLine = line.split(" ");
+                    String[] vertex1 = splittedLine[1].split("/");
+                    String[] vertex2 = splittedLine[2].split("/");
+                    String[] vertex3 = splittedLine[3].split("/");
+
+                    processVertex(vertex1, indices, textures, normals, texturesArray, normalsArray);
+                    processVertex(vertex2, indices, textures, normals, texturesArray, normalsArray);
+                    processVertex(vertex3, indices, textures, normals, texturesArray, normalsArray);
+
+                    line = bufferedReader.readLine();
+                }
+
+                bufferedReader.close();
+                fileReader.close();
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+
+            verticesArray = new float[vertices.size()*3];
+            indicesArray = new int[indices.size()];
+            int vertexPointer = 0;
+
+            for(Vector3f vertex: vertices) {
+                verticesArray[vertexPointer++] = vertex.x;
+                verticesArray[vertexPointer++] = vertex.y;
+                verticesArray[vertexPointer++] = vertex.z;
+            }
+
+            for(int i=0; i<indices.size(); i++) {
+                indicesArray[i] = indices.get(i);
+            }
+
+            return loader.loadToVAO(verticesArray, texturesArray, indicesArray);
+        } else {
+            return null;
+        }
+    }
+
+    private static void processVertex(String[] vertexData, List<Integer> indices, List<Vector2f> textures,
+                                      List<Vector3f> normals, float[] textureArray, float[] normalsArray) {
+        int currentVertexPointer = Integer.parseInt(vertexData[0]) -1;
+        indices.add(currentVertexPointer);
+        Vector2f currentTex = textures.get(Integer.parseInt(vertexData[1])-1);
+        textureArray[currentVertexPointer*2] = currentTex.x;
+        textureArray[currentVertexPointer*2+1] = 1 - currentTex.y;
+        Vector3f currentNorm = normals.get(Integer.parseInt(vertexData[2])-1);
+        normalsArray[currentVertexPointer*3] = currentNorm.x;
+        normalsArray[currentVertexPointer*3+1] = currentNorm.y;
+        normalsArray[currentVertexPointer*3+2] = currentNorm.z;
+
+    }
+
+
+
+}

client/src/main/java/core/engine/Renderer.java

@@ -29,7 +29,7 @@ public class Renderer {
     public void prepare() {
         GL11.glEnable(GL11.GL_DEPTH_TEST);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer
-        GL11.glClearColor(1,0,0,1);
+        GL11.glClearColor(5,195,221,1);
     }
 
     public void render(Entity entity, StaticShader shader) {

client/src/main/java/core/engine/entity/Camera.java

@@ -10,19 +10,19 @@ public class Camera {
     private float roll;
 
     public void moveLeft() {
-        position.x += 0.02f;
+        position.x += 0.5f;
     }
 
     public void moveForward() {
-        position.z -= 0.02f;
+        position.z -= .5f;
     }
 
     public void moveBackward() {
-        position.z += 0.02f;
+        position.z += .5f;
     }
 
     public void moveRight() {
-        position.x -= 0.02f;
+        position.x -= .5f;
     }
 
     public Vector3f getPosition() {