clean up, refactoring, static calls to reference passing, game interface

src/me/hammerle/snuviengine/Game.java

@@ -0,0 +1,40 @@
+package me.hammerle.snuviengine;
+
+import me.hammerle.snuviengine.api.Engine;
+import me.hammerle.snuviengine.api.IGame;
+import me.hammerle.snuviengine.api.KeyBinding;
+import me.hammerle.snuviengine.api.KeyHandler;
+import me.hammerle.snuviengine.api.Renderer;
+import static org.lwjgl.glfw.GLFW.*;
+
+public class Game implements IGame
+{
+    public final static KeyBinding UP = KeyHandler.register(GLFW_KEY_UP);
+    public final static KeyBinding DOWN = KeyHandler.register(GLFW_KEY_DOWN);
+    public final static KeyBinding LEFT = KeyHandler.register(GLFW_KEY_LEFT);
+    public final static KeyBinding RIGHT = KeyHandler.register(GLFW_KEY_RIGHT);
+    
+    public Game()
+    {
+    }
+
+    @Override
+    public void tick()
+    {        
+       
+    }
+    
+    @Override
+    public void renderTick(Renderer r, float lag)
+    { 
+        float y = 30;
+        r.setColorEnabled(true);
+        r.setTextureEnabled(true);
+        y = r.getFontRenderer().drawString(30, y, true, String.format("FPS %.1f", Engine.getFramesPerSecond()));
+    }
+
+    @Override
+    public void onStop()
+    {
+    }
+}

src/me/hammerle/snuviengine/Main.java

@@ -1,12 +1,17 @@
 package me.hammerle.snuviengine;
 
-import me.hammerle.snuviengine.game.Game;
+import me.hammerle.snuviengine.api.Engine;
 
 public class Main 
 {
     public static void main(String[] args)
     {
+        Engine.init("wusi", 1024, 620);
+        
+        Engine.setNanosPerTick(50_000_000);
+        Engine.setMaxFramesPerSecond(60);
+        
         Game game = new Game();
-        game.run();
+        Engine.start(game);
     }
 }

src/me/hammerle/snuviengine/api/Chunk.java

@@ -1,178 +0,0 @@
-package me.hammerle.snuviengine.api;
-
-import java.io.IOException;
-import java.nio.FloatBuffer;
-import me.hammerle.snuviengine.util.WrappedInputStream;
-import me.hammerle.snuviengine.util.WrappedOutputStream;
-import org.lwjgl.BufferUtils;
-import static org.lwjgl.opengl.GL11.*;
-import static org.lwjgl.opengl.GL15.*;
-import static org.lwjgl.opengl.GL20.*;
-import static org.lwjgl.opengl.GL30.*;
-
-public class Chunk
-{
-    public final static int CHUNK_SIZE = 8;
-    public final static int TILE_SIZE = 16;
-    public final static int LAYERS = 4;
-    public final static int LAST_BACK_LAYER = 1;
-    
-    private final short[][][] data = new short[LAYERS][CHUNK_SIZE][CHUNK_SIZE];
-    private final int chunkX;
-    private final int chunkY;
-    
-    private int vao;
-    private int vbo;
-    
-    private final FloatBuffer buffer = BufferUtils.createFloatBuffer(CHUNK_SIZE * CHUNK_SIZE * 24);
-    
-    private boolean[] dirty = new boolean[LAYERS];
-    
-    public Chunk(int x, int y)
-    {
-        this.chunkX = x;
-        this.chunkY = y;
-        
-        for(int i = 0; i < LAYERS; i++)
-        {
-            dirty[i] = true;
-        }
-        
-        Shader.addTask(() -> 
-        {
-            vao = glGenVertexArrays();
-            vbo = glGenBuffers();
-
-            GLHelper.glBindVertexArray(vao);
-            GLHelper.glBindBuffer(vbo);
-
-            glEnableVertexAttribArray(0);
-            glVertexAttribPointer(0, 2, GL_FLOAT, false, 16, 0);
-
-            glEnableVertexAttribArray(1);  
-            glVertexAttribPointer(1, 2, GL_FLOAT, false, 16, 8);
-            
-            glBufferData(GL_ARRAY_BUFFER, CHUNK_SIZE * CHUNK_SIZE * 96 * LAYERS, GL_STATIC_DRAW);
-        });
-    }
-    
-    public void read(WrappedInputStream in) throws IOException
-    {
-        for(int l = 0; l < LAYERS; l++)
-        {
-            for(int x = 0; x < CHUNK_SIZE; x++)
-            {
-                for(int y = 0; y < CHUNK_SIZE; y++)
-                {
-                    data[l][x][y] = in.readShort();
-                }
-            }
-        }
-    }
-    
-    public void write(WrappedOutputStream out) throws IOException
-    {
-        for(int l = 0; l < LAYERS; l++)
-        {
-            for(int x = 0; x < CHUNK_SIZE; x++)
-            {
-                for(int y = 0; y < CHUNK_SIZE; y++)
-                {
-                    out.writeShort(data[l][x][y]);
-                }
-            }
-        }
-    }
-    
-    private void rebuild(int layer)
-    {
-        for(int x = 0; x < CHUNK_SIZE; x++)
-        {
-            for(int y = 0; y < CHUNK_SIZE; y++)
-            {
-                short tile = data[layer][x][y];
-                float minX = x * TILE_SIZE;
-                float minY = y * TILE_SIZE;
-                float maxX = minX + TILE_SIZE;
-                float maxY = minY + TILE_SIZE;
-                float tMinX = (tile % 8) * 0.125f;
-                float tMinY = (tile / 8) * 0.0108695652f;
-                float tMaxX = tMinX + 0.125f;
-                float tMaxY = tMinY + 0.0108695652f;
-                
-                buffer.put(minX);
-                buffer.put(maxY);        
-                buffer.put(tMinX);
-                buffer.put(tMaxY);
-
-                buffer.put(minX);
-                buffer.put(minY);        
-                buffer.put(tMinX);
-                buffer.put(tMinY);
-
-                buffer.put(maxX);
-                buffer.put(maxY);        
-                buffer.put(tMaxX);
-                buffer.put(tMaxY);
-
-                buffer.put(maxX);
-                buffer.put(maxY);        
-                buffer.put(tMaxX);
-                buffer.put(tMaxY);
-
-                buffer.put(minX);
-                buffer.put(minY);        
-                buffer.put(tMinX);
-                buffer.put(tMinY);
-
-                buffer.put(maxX);
-                buffer.put(minY);        
-                buffer.put(tMaxX);
-                buffer.put(tMinY);
-            }
-        }
-        
-        buffer.flip();
-        GLHelper.glBindVertexArray(vao);
-        GLHelper.glBindBuffer(vbo);
-        glBufferSubData(GL_ARRAY_BUFFER, CHUNK_SIZE * CHUNK_SIZE * 96 * layer, buffer);
-    }
-    
-    public void drawBackground()
-    {
-        for(int i = 0; i <= LAST_BACK_LAYER; i++)
-        {
-            if(dirty[i])
-            {
-                rebuild(i);
-                dirty[i] = false;
-            }
-        }
-        GLHelper.glBindVertexArray(vao);
-        GLHelper.glBindBuffer(vbo);
-        Shader.pushMatrix();
-        Shader.translate(chunkX * CHUNK_SIZE * TILE_SIZE, chunkY * CHUNK_SIZE * TILE_SIZE);
-        Shader.updateMatrix();
-        Shader.popMatrix();
-        glDrawArrays(GL_TRIANGLES, 0, CHUNK_SIZE * CHUNK_SIZE * 6 * (LAST_BACK_LAYER + 1));
-    }
-    
-    public void drawForeground()
-    {
-        for(int i = LAST_BACK_LAYER + 1; i < LAYERS; i++)
-        {
-            if(dirty[i])
-            {
-                rebuild(i);
-                dirty[i] = false;
-            }
-        }
-        GLHelper.glBindVertexArray(vao);
-        GLHelper.glBindBuffer(vbo);
-        Shader.pushMatrix();
-        Shader.translate(chunkX * CHUNK_SIZE * TILE_SIZE, chunkY * CHUNK_SIZE * TILE_SIZE);
-        Shader.updateMatrix();
-        Shader.popMatrix();
-        glDrawArrays(GL_TRIANGLES, CHUNK_SIZE * CHUNK_SIZE * 6 * (LAST_BACK_LAYER + 1), CHUNK_SIZE * CHUNK_SIZE * 6 * (LAYERS - LAST_BACK_LAYER - 1));
-    }
-}

src/me/hammerle/snuviengine/api/ColorRenderer.java

@@ -9,34 +9,29 @@ import static org.lwjgl.opengl.GL30.*;
 
 public class ColorRenderer
 {
-    private int vao;
-    private int vbo;
-    
-    private ByteBuffer buffer = BufferUtils.createByteBuffer(64);
-    
     private final static int BUFFER_BYTE_LENGTH = 1024 * 1024;
     private final static int OBJECT_LENGTH = 64;
     
-    private int offset = BUFFER_BYTE_LENGTH - OBJECT_LENGTH;
+    private final int vao;
+    private final int vbo;
     
+    private ByteBuffer buffer = BufferUtils.createByteBuffer(64);
+    private int offset = BUFFER_BYTE_LENGTH - OBJECT_LENGTH;
     private float depth = 0.0f;
     
     protected ColorRenderer()
     {
-        Shader.addTask(() -> 
-        {
-            vao = glGenVertexArrays();
-            vbo = glGenBuffers();
-            
-            GLHelper.glBindVertexArray(vao);
-            GLHelper.glBindBuffer(vbo);
-            
-            glEnableVertexAttribArray(0);
-            glEnableVertexAttribArray(2);
-            
-            glVertexAttribPointer(0, 3, GL_FLOAT, false, 16, 0);
-            glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 16, 12);
-        });
+        vao = glGenVertexArrays();
+        vbo = glGenBuffers();
+
+        GLHelper.glBindVertexArray(vao);
+        GLHelper.glBindBuffer(vbo);
+
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(2);
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, false, 16, 0);
+        glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 16, 12);
     }
     
     public void setDepth(float depth)

src/me/hammerle/snuviengine/api/DirectTextureRenderer.java

@@ -9,34 +9,29 @@ import static org.lwjgl.opengl.GL30.*;
 
 public class DirectTextureRenderer
 {
-    private int vao;
-    private int vbo;
-    
-    private ByteBuffer buffer = BufferUtils.createByteBuffer(OBJECT_LENGTH);
-    
     private final static int BUFFER_BYTE_LENGTH = 1024 * 1024;
     private final static int OBJECT_LENGTH = 80;
     
-    private int offset = BUFFER_BYTE_LENGTH - OBJECT_LENGTH;
+    private final int vao;
+    private final int vbo;
     
+    private ByteBuffer buffer = BufferUtils.createByteBuffer(OBJECT_LENGTH);
+    private int offset = BUFFER_BYTE_LENGTH - OBJECT_LENGTH;    
     private float depth = 0.0f;
     
     protected DirectTextureRenderer()
     {
-        Shader.addTask(() -> 
-        {
-            vao = glGenVertexArrays();
-            vbo = glGenBuffers();
-            
-            GLHelper.glBindVertexArray(vao);
-            GLHelper.glBindBuffer(vbo);
+        vao = glGenVertexArrays();
+        vbo = glGenBuffers();
+
+        GLHelper.glBindVertexArray(vao);
+        GLHelper.glBindBuffer(vbo);
 
-            glEnableVertexAttribArray(0);
-            glVertexAttribPointer(0, 3, GL_FLOAT, false, 20, 0);
+        glEnableVertexAttribArray(0);
+        glVertexAttribPointer(0, 3, GL_FLOAT, false, 20, 0);
 
-            glEnableVertexAttribArray(1);  
-            glVertexAttribPointer(1, 2, GL_FLOAT, false, 20, 12);
-        });
+        glEnableVertexAttribArray(1);  
+        glVertexAttribPointer(1, 2, GL_FLOAT, false, 20, 12);
     }
     
     public void setDepth(float depth)

src/me/hammerle/snuviengine/api/Engine.java

@@ -7,30 +7,27 @@ import static org.lwjgl.glfw.GLFW.*;
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.system.MemoryUtil.*;
 
-public abstract class Engine
+public class Engine
 {
-    private static final String VERSION = "0.0.1";   
-    public static final int TILE_SIZE = 16;
-    public static final float SCALE = 2.0f;
+    private static long window;
     
-    private long window;
+    private static long fpsLimit = -1;
+    private static long sleep = 0;
+    private static long nanosPerTick = 10_000_000;
+    private static final int MAX_TICKS_PER_FRAME = 20;
     
-    private long fpsLimit = -1;
-    private long sleep = 0;
-    private long nanosPerTick = 10_000_000;
-    private final int maxTicksPerFrame = 20;
+    private static Timer fpsTimer;
+    private static Timer tpsTimer;
     
-    private final Timer fps = new Timer(60);
-    private final Timer tps = new Timer(1_000_000_000l / nanosPerTick);
+    private static Renderer renderer;
     
-    public Engine()
+    private Engine()
     {
     }    
-    
-    public final void run()
+
+    public static void start(IGame game)
     {
-        initGLFW();
-        loop();
+        loop(game);
 
         glfwFreeCallbacks(window);
         glfwDestroyWindow(window);
@@ -43,12 +40,12 @@ public abstract class Engine
         }
     }
     
-    public final void stop()
+    public static void stop()
     {
         glfwSetWindowShouldClose(window, true);
     }
 
-    private void initGLFW()
+    public static void init(String name, int width, int height)
     {
         GLFWErrorCallback.createPrint(System.err).set();
         
@@ -65,10 +62,10 @@ public abstract class Engine
         glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
         glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
-        window = glfwCreateWindow(Shader.BASE_WIDTH, Shader.BASE_HEIGHT, "SnuviEngine " + VERSION, NULL, NULL);
+        window = glfwCreateWindow(width, height, name, NULL, NULL);
         if(window == NULL)
         {
-            throw new RuntimeException("Failed to create the GLFW window");
+            throw new IllegalStateException("Failed to create the GLFW window");
         }
 
         glfwSetKeyCallback(window, (w, key, scancode, action, mods) -> 
@@ -83,21 +80,25 @@ public abstract class Engine
             }
         });
         
+        glfwMakeContextCurrent(window);
+        glfwSwapInterval(1);
+       
+        GL.createCapabilities();
+        
+        renderer = new Renderer(width, height);
+        fpsTimer = new Timer(60);
+        tpsTimer = new Timer(1_000_000_000l / nanosPerTick);
+        
         glfwSetFramebufferSizeCallback(window, (w, fwidth, fheight) -> 
         {
             glViewport(0, 0, fwidth, fheight);
-            Shader.setViewPort(fwidth, fheight);
+            renderer.setViewPort(fwidth, fheight);
         });
         
-        //glfwSetWindowAspectRatio(window, 16, 9);
-        
-        glfwMakeContextCurrent(window);
-        glfwSwapInterval(1);
-       
         glfwShowWindow(window);
     }
     
-    private void sleep(long nanos)
+    private static void sleep(long nanos)
     {
         if(nanos < 0)
         {
@@ -126,15 +127,10 @@ public abstract class Engine
         }
     }
 
-    private void loop()
+    private static void loop(IGame game)
     {
-        GL.createCapabilities();
-        
-        Shader.init();
-        init();
-        
-        fps.update();
-        tps.update();
+        fpsTimer.update();
+        tpsTimer.update();
         long lag = 0;
         
         while(!glfwWindowShouldClose(window))
@@ -145,23 +141,23 @@ public abstract class Engine
             
             if(fpsLimit > 0)
             {
-                sleep(fpsLimit - fps.getCurrentTime());
+                sleep(fpsLimit - fpsTimer.getCurrentTime());
             }
-            fps.update();
-            lag += fps.getTime();
+            fpsTimer.update();
+            lag += fpsTimer.getTime();
 
             int ticksPerFrame = 0;
             while(lag >= nanosPerTick)
             {
                 lag -= nanosPerTick;
                 
-                tps.update();
+                tpsTimer.update();
                 
                 KeyHandler.tick();
-                tick();
+                game.tick();
                 
                 ticksPerFrame++;
-                if(ticksPerFrame >= maxTicksPerFrame)
+                if(ticksPerFrame >= MAX_TICKS_PER_FRAME)
                 {
                     long skip = lag / nanosPerTick;
                     lag -= skip * nanosPerTick;
@@ -173,58 +169,51 @@ public abstract class Engine
                 }
             }
             
-            Shader.doTasks();
+            game.renderTick(renderer, (float) lag / nanosPerTick);
             
-            renderTick((float) lag / nanosPerTick);
-            
-            tps.draw();
-            fps.draw();
+            tpsTimer.draw(renderer);
+            fpsTimer.draw(renderer);
 
             glfwPollEvents();
         }
-        onStop();
+        game.onStop();
     }
     
-    public final void setNanosPerTick(long nanos)
+    public static void setNanosPerTick(long nanos)
     {
         nanosPerTick = nanos;
-        tps.setExpectedValue(1_000_000_000l / nanos);
+        tpsTimer.setExpectedValue(1_000_000_000l / nanos);
     }
     
-    public final long getNanosPerTick()
+    public static long getNanosPerTick()
     {
         return nanosPerTick;
     }
     
-    public final double getTps()
+    public static double getTicksPerSecond()
     {
-        return tps.getCallsPerSecond();
+        return tpsTimer.getCallsPerSecond();
     }
     
-    public final void setRenderTps(boolean active)
+    public static void setRenderTicksPerSecond(boolean active)
     {
-        tps.setActive(active);
+        tpsTimer.setActive(active);
     }
     
-    public final double getFps()
+    public static double getFramesPerSecond()
     {
-        return fps.getCallsPerSecond();
+        return fpsTimer.getCallsPerSecond();
     }
     
-    public final void setMaxFps(int max)
+    public static void setMaxFramesPerSecond(int max)
     {
         fpsLimit = 1_000_000_000 / max;
     }
     
-    public final void setRenderFps(boolean active)
+    public static void setRenderFramesPerSecond(boolean active)
     {
-        fps.setActive(active);
+        fpsTimer.setActive(active);
     }
-    
-    public abstract void init();
-    public abstract void tick();
-    public abstract void renderTick(float lag);
-    public abstract void onStop();
 }
 
 

src/me/hammerle/snuviengine/api/FontRenderer.java

@@ -11,23 +11,15 @@ import static org.lwjgl.opengl.GL30.*;
 
 public class FontRenderer
 {
-    private final static float ERROR = 0.0f;
-    
-    private final static Texture[] FONT_TEXTURE = new Texture[]
-    {
-        new Texture("font8x8.png", true), 
-        new Texture("font16x16.png", true), 
-        new Texture("font24x24.png", true)
-    };
-    
     public static final char COLOR_CHAR = '&';
-    
     private static final float[] COLORS = new float[128];
     private static final float[] DARK_COLORS = new float[128];
-    
     private static final int FONT_SIZE = 8;
     private static final int LINE_STEP = 1;
-    private static final float SHADOW_STEP = 1f;
+    private static final float SHADOW_STEP = 1.0f;
+    private final static int MAX_LENGTH = 256;
+    private final static int BUFFER_BYTE_LENGTH = 1024 * 1024;
+    private final static int OBJECT_LENGTH = 120 * MAX_LENGTH * 2;
     
     static
     {
@@ -67,42 +59,45 @@ public class FontRenderer
         DARK_COLORS['f'] = Float.intBitsToFloat(Color.darken(Color.get(255, 255, 255), factor));
     }
     
-    private int vao;
-    private int vbo;
+    private final Texture[] FONT_TEXTURE = new Texture[]
+    {
+        new Texture("font8x8.png", true), 
+        new Texture("font16x16.png", true), 
+        new Texture("font24x24.png", true)
+    };
     
-    private float color;
+    private final int vao;
+    private final int vbo;
     
+    private float color = 0.0f;
+    private int scale = 1;
     private ByteBuffer buffer = BufferUtils.createByteBuffer(OBJECT_LENGTH);
-    
-    private final static int MAX_LENGTH = 256;
-    private final static int BUFFER_BYTE_LENGTH = 1024 * 1024;
-    private final static int OBJECT_LENGTH = 120 * MAX_LENGTH * 2;
-    
     private int offset = BUFFER_BYTE_LENGTH - OBJECT_LENGTH;
     
     protected FontRenderer()
     {
-        Shader.addTask(() -> 
-        {
-            vao = glGenVertexArrays();
-            vbo = glGenBuffers();
+        vao = glGenVertexArrays();
+        vbo = glGenBuffers();
 
-            GLHelper.glBindVertexArray(vao);
-            GLHelper.glBindBuffer(vbo);
-            
-            glEnableVertexAttribArray(0);
-            glEnableVertexAttribArray(1); 
-            glEnableVertexAttribArray(2);
-            
-            glVertexAttribPointer(0, 2, GL_FLOAT, false, 20, 0);
-            glVertexAttribPointer(1, 2, GL_FLOAT, false, 20, 8);
-            glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 20, 16);
-        });
+        GLHelper.glBindVertexArray(vao);
+        GLHelper.glBindBuffer(vbo);
+
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(1); 
+        glEnableVertexAttribArray(2);
+
+        glVertexAttribPointer(0, 2, GL_FLOAT, false, 20, 0);
+        glVertexAttribPointer(1, 2, GL_FLOAT, false, 20, 8);
+        glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 20, 16);
+    }
+    
+    protected void setScale(int scale)
+    {
+        this.scale = scale;
     }
 
     private void addRectangle(float minX, float minY, char c)
     {
-        float scale = Shader.getViewScale();
         minY = Math.round(minY * scale) / scale;
         minX = Math.round(minX * scale) / scale;
         
@@ -176,7 +171,7 @@ public class FontRenderer
         glUnmapBuffer(GL_ARRAY_BUFFER);
         
         GLHelper.glBindVertexArray(vao);
-        FONT_TEXTURE[Math.min(Shader.getViewScale() - 1, FONT_TEXTURE.length - 1)].bind();
+        FONT_TEXTURE[Math.min(scale - 1, FONT_TEXTURE.length - 1)].bind();
         
         glDrawArrays(GL_TRIANGLES, offset / 20, buffer.limit() / 20);
 

src/me/hammerle/snuviengine/api/IGame.java

@@ -0,0 +1,8 @@
+package me.hammerle.snuviengine.api;
+
+public interface IGame
+{
+    public void tick();
+    public void renderTick(Renderer r, float lag);
+    public void onStop();
+}

src/me/hammerle/snuviengine/api/KeyDuplicateException.java

@@ -1,9 +0,0 @@
-package me.hammerle.snuviengine.api;
-
-public class KeyDuplicateException extends IllegalArgumentException
-{
-    public KeyDuplicateException(String message)
-    {
-        super(message);
-    }
-}

src/me/hammerle/snuviengine/api/KeyHandler.java

@@ -7,12 +7,12 @@ public final class KeyHandler
     private final static HashMap<Integer, KeyBinding> BINDINGS = new HashMap<>();
     private static KeyBinding rebind = null;
     
-    public static KeyBinding register(int key) throws KeyDuplicateException
+    public static KeyBinding register(int key)
     {
         KeyBinding binding = new KeyBinding(key);
         if(BINDINGS.putIfAbsent(key, binding) != null)
         {
-            throw new KeyDuplicateException("the key '" + key + "' has already been registered");
+            throw new IllegalArgumentException(String.format("the key '%s' has already been registered", key));
         }
         return binding;
     }

src/me/hammerle/snuviengine/api/Shader.java → src/me/hammerle/snuviengine/api/Renderer.java

@@ -4,69 +4,59 @@ import java.io.IOException;
 import java.net.URL;
 import java.nio.FloatBuffer;
 import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
 import java.util.Scanner;
 import org.lwjgl.BufferUtils;
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.opengl.GL14.*;
 import static org.lwjgl.opengl.GL20.*;
 
-public final class Shader
+public final class Renderer
 {
-    private static int program = -1;
+    private final int program;
     
-    public final static int BASE_WIDTH = 1024;
-    public final static int BASE_HEIGHT = 620;
+    private float width;
+    private float height;
+    private int scale;
     
-    private static int width = 512;
-    private static int height = 310;
-    private static int scale = 2;
-    
-    private static final List<Runnable> TASKS = new LinkedList<>();
-    
-    protected static boolean initDone = false;
-    
-    private final static FontRenderer FONT_RENDERER = new FontRenderer();
-    private final static ColorRenderer COLOR_RENDERER = new ColorRenderer();
-    private final static DirectTextureRenderer TEXTURE_RENDERER = new DirectTextureRenderer();
+    private final FontRenderer fontRenderer;
+    private final ColorRenderer colorRenderer = new ColorRenderer();
+    private final DirectTextureRenderer textureRenderer = new DirectTextureRenderer();
     
     // uniform stuff
-    private static int unifViewMatrix = -1;
-    private static int unifModelMatrix = -1;
-    private static MatrixStack modelMatrix;
-    
-    private static int unifAmbientLight = -1;
-    private static int[][] unifLight;
-    
-    private static int unifUseTexture = -1;
-    private static int unifUseColor = -1;
-    private static int unifUseLight = -1;
-    private static int unifUseMixColor = -1;
-    private static int unifMixColorLoc = -1;
-    private static float[] unifMixColor = new float[] {0.0f, 0.0f, 0.0f, 0.0f};
-    
-    protected static void init()
+    private final int unifViewMatrix;
+    private final int unifModelMatrix;
+    private final MatrixStack modelMatrix = new MatrixStack(20);
+    
+    private final int unifAmbientLight;
+    private final int[][] unifLight = new int[32][3];
+    
+    private final int unifUseTexture;
+    private final int unifUseColor;
+    private final int unifUseLight;
+    private final int unifUseMixColor;
+    private final int unifMixColorLoc;
+    private final float[] unifMixColor = new float[] {0.0f, 0.0f, 0.0f, 0.0f};
+ 
+    protected Renderer(int width, int height)
     {
         program = createShaderProgram("vertex.vs", "fragment.fs");
         glUseProgram(program);
         
         unifViewMatrix = glGetUniformLocation(program, "viewMatrix");
-        updateViewMatrix();
+        fontRenderer = new FontRenderer();
+        setViewPort(width, height);
         
         unifModelMatrix = glGetUniformLocation(program, "modelMatrix");
-        modelMatrix = new MatrixStack(20);
         updateMatrix();
         
         unifAmbientLight = glGetUniformLocation(program, "ambientLight");
         setAmbientLight(1.0f, 1.0f, 1.0f);
         
-        unifLight = new int[32][3];
         for(int index = 0; index < unifLight.length; index++)
         {
-            unifLight[index][0] = glGetUniformLocation(program, "lights[" + index + "].color");
-            unifLight[index][1] = glGetUniformLocation(program, "lights[" + index + "].pos");
-            unifLight[index][2] = glGetUniformLocation(program, "lights[" + index + "].strength");
+            unifLight[index][0] = glGetUniformLocation(program, String.format("lights[%d].color", index));
+            unifLight[index][1] = glGetUniformLocation(program, String.format("lights[%d].pos", index));
+            unifLight[index][2] = glGetUniformLocation(program, String.format("lights[%d].strength", index));
             setLightColor(index, 0.0f, 0.0f, 0.0f);
             setLightLocation(index, 0.0f, 0.0f);
             setLightStrength(index, 0.0f);
@@ -86,45 +76,25 @@ public final class Shader
         unifMixColorLoc = glGetUniformLocation(program, "mixColor");
         setMixColor(0.0f, 0.0f, 0.0f, 0.0f);
         
-        setViewPort(BASE_WIDTH, BASE_HEIGHT);
-        initDone = true;
-    }
-    
-    protected static int getProgram()
-    {
-        return program;
+        setViewPort(width, height);
     }
     
-    protected static void addTask(Runnable r)
+    public FontRenderer getFontRenderer()
     {
-        TASKS.add(r);
+        return fontRenderer;
     }
     
-    protected static void doTasks()
+    public ColorRenderer getColorRenderer()
     {
-        if(!TASKS.isEmpty())
-        {
-            TASKS.forEach(r -> r.run());
-            TASKS.clear();
-        }
-    }
-    
-    public static FontRenderer getFontRenderer()
-    {
-        return FONT_RENDERER;
+        return colorRenderer;
     }
     
-    public static ColorRenderer getColorRenderer()
+    public DirectTextureRenderer getTextureRenderer()
     {
-        return COLOR_RENDERER;
+        return textureRenderer;
     }
     
-    public static DirectTextureRenderer getTextureRenderer()
-    {
-        return TEXTURE_RENDERER;
-    }
-    
-    private static void updateViewMatrix()
+    private void updateViewMatrix()
     {
         FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
         
@@ -153,117 +123,119 @@ public final class Shader
         glUniformMatrix4fv(unifViewMatrix, false, buffer);
     }
     
-    protected static void setViewPort(int width, int height)
+    protected void setViewPort(float width, float height)
     {
         scale = 1;
         while(width / (scale + 1) >= 400 && height / (scale + 1) >= 300)
         {
             scale++;
         }
+        
+        fontRenderer.setScale(scale);
 
-        Shader.width = width / scale;
-        Shader.height = height / scale;
+        this.width = width / scale;
+        this.height = height / scale;
         
         updateViewMatrix();
     }
     
-    public static int getViewScale()
+    public int getViewScale()
     {
         return scale;
     }
     
-    public static int getViewWidth()
+    public float getViewWidth()
     {
         return width;
     }
     
-    public static int getViewHeight()
+    public float getViewHeight()
     {
         return height;
     }
     
-    public static void updateMatrix()
+    public void updateMatrix()
     {
         glUniformMatrix4fv(unifModelMatrix, false, modelMatrix.getData());
     }
     
-    public static void pushMatrix()
+    public void pushMatrix()
     {
         modelMatrix.push();
     }
     
-    public static void popMatrix()
+    public void popMatrix()
     {
         modelMatrix.pop();
     }
     
-    public static void translate(float tx, float ty)
+    public void translate(float tx, float ty)
     {
         modelMatrix.translate(tx, ty);
     }
     
-    public static void translateTo(float tx, float ty)
+    public void translateTo(float tx, float ty)
     {
         modelMatrix.translateTo(tx, ty);
     }
     
-    public static void scale(float sx, float sy)
+    public void scale(float sx, float sy)
     {
         modelMatrix.scale(sx, sy);
     }
     
-    public static void rotate(float angle)
+    public void rotate(float angle)
     {
         modelMatrix.rotate(angle);
     }
     
-    public static void setAmbientLight(float r, float g, float b)
+    public void setAmbientLight(float r, float g, float b)
     {
         glUniform3f(unifAmbientLight, r, g, b);
     }
     
-    private static void checkLightIndex(int index)
+    private void checkLightIndex(int index)
     {
         if(index < 0 || index > unifLight.length)
         {
-            throw new ShaderException("'" + index + "' is not a valid light index");
+            throw new ShaderException("'%d' is not a valid light index", index);
         }
     }
     
-    public static void setLightColor(int index, float r, float g, float b)
+    public void setLightColor(int index, float r, float g, float b)
     {
         checkLightIndex(index);
         glUniform3f(unifLight[index][0], r, g, b);
     }
     
-    public static void setLightLocation(int index, float x, float y)
+    public void setLightLocation(int index, float x, float y)
     {
         checkLightIndex(index);
         glUniform2f(unifLight[index][1], x, y);
     }
     
-    public static void setLightStrength(int index, float strength)
+    public void setLightStrength(int index, float strength)
     {
         checkLightIndex(index);
         glUniform1f(unifLight[index][2], strength);
     }
     
-    public static void setTextureEnabled(boolean use)
+    public void setTextureEnabled(boolean use)
     {
         glUniform1i(unifUseTexture, use ? 1 : 0);
     }
     
-    public static void setColorEnabled(boolean use)
+    public void setColorEnabled(boolean use)
     {
         glUniform1i(unifUseColor, use ? 1 : 0);
     }
     
-    public static void setMixColorEnabled(boolean use)
+    public void setMixColorEnabled(boolean use)
     {
         glUniform1i(unifUseMixColor, use ? 1 : 0);
     }
     
-    public static void setMixColor(float r, float g, float b, float a)
+    public void setMixColor(float r, float g, float b, float a)
     {
         unifMixColor[0] = r;
         unifMixColor[1] = g;
@@ -272,12 +244,12 @@ public final class Shader
         glUniform4fv(unifMixColorLoc, unifMixColor);
     }
     
-    public static void setLightEnabled(boolean use)
+    public void setLightEnabled(boolean use)
     {
         glUniform1i(unifUseLight, use ? 1 : 0);
     }
     
-    public static void setDepthTestEnabled(boolean use)
+    public void setDepthTestEnabled(boolean use)
     {
         if(use)
         {
@@ -290,7 +262,7 @@ public final class Shader
         }
     }
     
-    public static void setBlendingEnabled(boolean use)
+    public void setBlendingEnabled(boolean use)
     {
         if(use)
         {
@@ -308,12 +280,12 @@ public final class Shader
     // general stuff
     // -------------------------------------------------------------------------
     
-    private static String[] readFile(String name)
+    private String[] readFile(String name)
     {
-        URL url = Shader.class.getClassLoader().getResource("me/hammerle/snuviengine/shader/" + name);
+        URL url = Renderer.class.getClassLoader().getResource("me/hammerle/snuviengine/shader/" + name);
         if(url == null)
         {
-            throw new ShaderException("failed reading shader '" + name + "'");
+            throw new ShaderException("failed reading shader '%s'", name);
         }
         ArrayList<String> strings = new ArrayList<>();
         try(Scanner scanner = new Scanner(url.openStream()))
@@ -326,11 +298,11 @@ public final class Shader
         }
         catch(IOException ex)
         {
-            throw new ShaderException("failed reading shader '" + name + "'");
+            throw new ShaderException("failed reading shader '%s'", name);
         }
     }
     
-    private static String getError()
+    private String getError()
     {
         StringBuilder sb = new StringBuilder();
         
@@ -345,12 +317,12 @@ public final class Shader
         return sb.toString();
     }
     
-    private static int createShaderProgram(String vertex, String fragment)
+    private int createShaderProgram(String vertex, String fragment)
     {
         // ---------------------------------------------------------------------
         // vertex shader
         // ---------------------------------------------------------------------
-        
+          
         String vShaderSource[] = readFile(vertex);
         
         int vShader = glCreateShader(GL_VERTEX_SHADER);
@@ -360,13 +332,13 @@ public final class Shader
         String error = getError();
         if(!error.isEmpty())
         {
-            throw new ShaderException("failed compiling vertex shader '" + vertex + "' " + error);
+            throw new ShaderException("failed compiling vertex shader '%s' %s", vertex, error);
         }
         
         int compiled = glGetShaderi(vShader, GL_COMPILE_STATUS);
         if(compiled != 1)
         {
-            throw new ShaderException("failed compiling vertex shader '" + vertex + "' " + compiled + " " + glGetShaderInfoLog(vShader));
+            throw new ShaderException("failed compiling vertex shader '%s' %d %s", vertex, compiled, glGetShaderInfoLog(vShader));
         }
         
         // ---------------------------------------------------------------------
@@ -382,13 +354,13 @@ public final class Shader
         error = getError();
         if(!error.isEmpty())
         {
-            throw new ShaderException("failed compiling fragment shader '" + fragment + "' " + error);
+            throw new ShaderException("failed compiling fragment shader '%s' %s", fragment, error);
         }
         
         compiled = glGetShaderi(fShader, GL_COMPILE_STATUS);
         if(compiled != 1)
         {
-            throw new ShaderException("failed compiling fragment shader '" + fragment + "' " + compiled + " " + glGetShaderInfoLog(fShader));
+            throw new ShaderException("failed compiling fragment shader '%s' %d %s", fragment, compiled, glGetShaderInfoLog(fShader));
         }
         
         // ---------------------------------------------------------------------
@@ -403,13 +375,13 @@ public final class Shader
         error = getError();
         if(!error.isEmpty())
         {
-            throw new ShaderException("failed linking shaders '" + vertex + "' and '" + fragment + "' " + error);
+            throw new ShaderException("failed linking shaders '%s' and '%s' %s", vertex, fragment, error);
         }
         
         compiled = glGetProgrami(vfprogram, GL_LINK_STATUS);
         if(compiled != 1)
         {
-            throw new ShaderException("failed linking shaders '" + vertex + "' and '" + fragment + "' " + compiled + " " + glGetProgramInfoLog(vfprogram));
+            throw new ShaderException("failed linking shaders '%s' and '%s' %d %s", vertex, fragment, compiled, glGetProgramInfoLog(vfprogram));
         }
 
         glDeleteShader(vShader);

src/me/hammerle/snuviengine/api/ShaderException.java

@@ -2,8 +2,8 @@ package me.hammerle.snuviengine.api;
 
 public class ShaderException extends RuntimeException
 {
-    public ShaderException(String message)
+    public ShaderException(String format, Object... args)
     {
-        super(message);
+        super(String.format(format, args));
     }
 }

src/me/hammerle/snuviengine/api/Texture.java

@@ -9,9 +9,7 @@ import org.lwjgl.BufferUtils;
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.opengl.GL12.*;
 import static org.lwjgl.opengl.GL13.*;
-import static org.lwjgl.opengl.GL20.*;
 import static org.lwjgl.opengl.GL30.*;
-import static org.lwjgl.opengl.GL33.*;
 
 public class Texture
 {
@@ -43,13 +41,13 @@ public class Texture
                 }
                 catch(IOException | IllegalArgumentException ex)
                 {
-                    throw new TextureException("cannot read texture file '" + paths[i] + "'");
+                    throw new TextureException("cannot read texture file '%s'", paths[i]);
                 }
 
                 if(offsetX + image.getWidth() > w || offsetY + image.getHeight() > h)
                 {
                     System.out.println(offsetX + " " + image.getWidth() + " " +  w + " " + offsetY + " " + image.getHeight() + " " + h);
-                    throw new TextureException("animation image '" + paths[i] + "'is out of range");
+                    throw new TextureException("animation image '%s'is out of range", paths[i]);
                 }
                 
                 wi[i] = image.getWidth();
@@ -70,28 +68,19 @@ public class Texture
         
         public void nextFrame()
         {
-            glActiveTexture(GL_TEXTURE0 + textureUnit);
+            glActiveTexture(GL_TEXTURE0);
             glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, wi[index], he[index], GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, data[index]);
             index = (index + 1) % data.length;
         }
     }
     
+    private static int boundTexture = -1;
     private int texture = -1; 
-    private final String path;
     private final int w;
     private final int h;
-    private IntBuffer buffer;
     
-    private static int textureUnits = 1;
-    private int textureUnit = -1;
-    private static int boundSampler = -1;
-    private int sampler = -1;
-    private int sampLoc = -1;
-    
-    public Texture(String path, boolean internal)
+    protected Texture(String path, boolean internal)
     {
-        this.path = path;
-        
         BufferedImage image;
         try
         {
@@ -106,12 +95,12 @@ public class Texture
         }
         catch(IOException | IllegalArgumentException ex)
         {
-            throw new TextureException("cannot read texture file '" + path + "'");
+            throw new TextureException("cannot read texture file '%s'", path);
         }
         
         w = image.getWidth();
         h = image.getHeight();
-        buffer = BufferUtils.createIntBuffer(w * h);
+        IntBuffer buffer = BufferUtils.createIntBuffer(w * h);
         for(int y = 0; y < h; y++)
         {
             for(int x = 0; x < w; x++)
@@ -121,8 +110,16 @@ public class Texture
             }
         }
         buffer.flip();
-        
-        Shader.addTask(() -> loadTexture());
+
+        glActiveTexture(GL_TEXTURE0);
+        texture = glGenTextures();
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buffer);
+        glGenerateMipmap(GL_TEXTURE_2D);
     }
     
     public Texture(String path)
@@ -133,45 +130,18 @@ public class Texture
     public Animation addAnimation(int offsetX, int offsetY, String... paths)
     {
         return new Animation(offsetX, offsetY, paths);
-    }
-    
-    private void loadTexture()
-    {
-        if(texture != -1)
-        {
-            throw new TextureException("a texture is already loaded");
-        }
-        
-        sampler = glGenSamplers();
-        sampLoc = glGetUniformLocation(Shader.getProgram(), "samp");
-        glUniform1i(sampLoc, sampler);
-
-        textureUnit = textureUnits;
-        textureUnits++;
-        glBindSampler(GL_TEXTURE0 + textureUnit, sampler);
-        
-        glActiveTexture(GL_TEXTURE0 + textureUnit);
-        texture = glGenTextures();
-        glBindTexture(GL_TEXTURE_2D, texture);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buffer);
-        buffer = null;
-        glGenerateMipmap(GL_TEXTURE_2D);
-    }    
+    } 
 
     public void bind()
     {
         if(texture == -1)
         {
-            throw new TextureException("cannot load non loaded texture");
+            throw new TextureException("cannot bind non loaded texture");
         }
-        if(boundSampler != sampler)
+        if(boundTexture != texture)
         {
-            boundSampler = sampler; 
-            glUniform1i(sampLoc, sampler);
+            boundTexture = texture; 
+            glBindTexture(GL_TEXTURE_2D, texture);
         }
     }
 }

src/me/hammerle/snuviengine/api/TextureException.java

@@ -2,8 +2,8 @@ package me.hammerle.snuviengine.api;
 
 public class TextureException extends RuntimeException
 {
-    public TextureException(String message)
+    public TextureException(String format, Object... args)
     {
-        super(message);
+        super(String.format(format, args));
     }
 }

src/me/hammerle/snuviengine/api/TextureRenderer.java

@@ -9,29 +9,18 @@ import static org.lwjgl.opengl.GL30.*;
 
 public class TextureRenderer
 {
-    private int vao;
-    private int vbo;
+    private final int vao;
+    private final int vbo;
     
     private int triangles = 0;
     private FloatBuffer buffer;
     
     private boolean built = false;
     
-    public TextureRenderer(int triangles, boolean initDelayed)
+    public TextureRenderer(int triangles)
     {
         buffer = BufferUtils.createFloatBuffer(triangles * 12);
-        if(initDelayed)
-        {
-            Shader.addTask(() -> init());
-        }
-        else
-        {
-            init();
-        }
-    }
-    
-    private void init()
-    {   
+       
         vao = glGenVertexArrays();
         vbo = glGenBuffers();
 
@@ -45,11 +34,6 @@ public class TextureRenderer
         glVertexAttribPointer(1, 2, GL_FLOAT, false, 16, 8);
     }
     
-    public TextureRenderer(int triangles)
-    {
-        this(triangles, true);
-    }
-    
     public void addTriangle(float x1, float y1, float x2, float y2, float x3, float y3, float tx1, float ty1, float tx2, float ty2, float tx3, float ty3)
     {
         if(buffer.position() + 12 > buffer.capacity())
@@ -91,10 +75,6 @@ public class TextureRenderer
     
     public void build()
     {
-        if(!Shader.initDone)
-        {
-            throw new ShaderException("build called too early");
-        }
         if(triangles == 0 || built)
         {
             return;
@@ -134,8 +114,6 @@ public class TextureRenderer
         buffer = null;
         glDeleteVertexArrays(vao);
         glDeleteBuffers(vbo);
-        vao = -1;
-        vbo = -1;
         built = false;
     }
 }

src/me/hammerle/snuviengine/api/Timer.java

@@ -17,8 +17,8 @@ public class Timer
     private double callsPerSecond = 0;
     private long lastTime = System.nanoTime();
     
-    private int vao;
-    private int vbo;
+    private final int vao;
+    private final int vbo;
     
     private final FloatBuffer buffer = BufferUtils.createFloatBuffer(18);
     
@@ -29,22 +29,20 @@ public class Timer
     protected Timer(float expectedValue)
     {
         this.expectedValue = expectedValue;
-        Shader.addTask(() -> 
-        {
-            vao = glGenVertexArrays();
-            vbo = glGenBuffers();
-            
-            GLHelper.glBindVertexArray(vao);
-            GLHelper.glBindBuffer(vbo);
-            
-            glEnableVertexAttribArray(0);
-            glEnableVertexAttribArray(2);
-            
-            glVertexAttribPointer(0, 2, GL_FLOAT, false, 12, 0);
-            glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 12, 8);
-            
-            glBufferData(GL_ARRAY_BUFFER, SIZE * buffer.limit() * 4, GL_STATIC_DRAW);
-        });
+
+        vao = glGenVertexArrays();
+        vbo = glGenBuffers();
+
+        GLHelper.glBindVertexArray(vao);
+        GLHelper.glBindBuffer(vbo);
+
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(2);
+
+        glVertexAttribPointer(0, 2, GL_FLOAT, false, 12, 0);
+        glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 12, 8);
+
+        glBufferData(GL_ARRAY_BUFFER, SIZE * buffer.limit() * 4, GL_STATIC_DRAW);
     }
     
     protected void setActive(boolean active)
@@ -132,12 +130,12 @@ public class Timer
         return callsPerSecond;
     }
     
-    protected void draw()
+    protected void draw(Renderer r)
     {
         if(active)
         {
-            Shader.setTextureEnabled(false);
-            Shader.setColorEnabled(true);
+            r.setTextureEnabled(false);
+            r.setColorEnabled(true);
 
             GLHelper.glBindBuffer(vbo);
             GLHelper.glBindVertexArray(vao);

src/me/hammerle/snuviengine/game/BoxList.java

@@ -1,233 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import java.util.ConcurrentModificationException;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.function.Consumer;
-
-public class BoxList<T extends IBoxListEntry>
-{
-    private double maxWidth = 0;
-    private double maxHeight = 0;
-    
-    private final T[] entities;
-    private int lastFreeEntity;
-    public boolean isIterating = false;
-    
-    public static class Node
-    {
-        private Node next = null;
-        private Node previous = null;
-        private int index = -1;
-        private int x = -1;
-        private int y = -1;
-    }
-    
-    private final double boxMinX;
-    private final double boxMinY;
-    private final double boxMaxX;
-    private final double boxMaxY;
-    
-    private final double size;
-    
-    private final Node[][] nodes;
-    
-    private final int partionX;
-    private final int partionY;
-    
-    public int amount = 0;
-        
-    public BoxList(int maxObjects, double x1, double y1, double x2, double y2, double size)
-    {
-        this.size = size;
-        
-        boxMinX = Math.min(x1, x2);
-        boxMinY = Math.min(y1, y2);
-        
-        partionX = (int) Math.ceil((Math.max(x1, x2) - boxMinX) / size);
-        partionY = (int) Math.ceil((Math.max(y1, y2) - boxMinX) / size);
-        
-        boxMaxX = partionX * size;
-        boxMaxY = partionY * size;
-        
-        nodes = new Node[partionX][partionY];
-        
-        entities = (T[]) new IBoxListEntry[maxObjects];
-        lastFreeEntity = entities.length - 1;
-    }
-    
-    public Node add(T ent)
-    {
-        if(isIterating)
-        {
-            throw new ConcurrentModificationException();
-        }
-        
-        if(maxHeight < ent.getHeight() / 2)
-        {
-            maxHeight = ent.getHeight() / 2;
-        }
-        
-        if(maxWidth < ent.getWidth() / 2)
-        {
-            maxWidth = ent.getWidth() / 2;
-        }
-        
-        amount++;
-        
-        int x = Math.max(Math.min((int) ((ent.getCenterX() + boxMinX) / size), partionX - 1), 0);
-        int y = Math.max(Math.min((int) ((ent.getCenterY() + boxMinY) / size), partionY - 1), 0);
-        
-        Node n = new Node();
-        n.index = lastFreeEntity;
-        n.x = x;
-        n.y = y;
-        
-        if(nodes[x][y] == null)
-        {
-            nodes[x][y] = n;
-        }
-        else
-        {
-            n.next = nodes[x][y];
-            nodes[x][y].previous = n;
-            nodes[x][y] = n;
-        }
-        
-        entities[lastFreeEntity--] = ent;
-        
-        return n;
-    }
-    
-    public void remove(Node n)
-    {
-        if(isIterating)
-        {
-            throw new ConcurrentModificationException();
-        }
-        
-        if(n.previous != null)
-        {
-            n.previous.next = n.next;
-        }
-        else
-        {
-            nodes[n.x][n.y] = n.next;
-        }
-        
-        if(n.next != null)
-        {
-            n.next.previous = n.previous;
-        }
-        
-        if(lastFreeEntity + 1 == entities.length)
-        {
-            entities[n.index] = null;
-        }
-        else
-        {
-            lastFreeEntity++;
-            T ent = entities[lastFreeEntity];
-            entities[n.index] = ent;
-            ent.getNode().index = n.index;
-            entities[lastFreeEntity] = null;
-        }
-        
-        n.next = null;
-        n.previous = null;
-        
-        amount--;
-    }
-    
-    public void update(Entity ent)
-    {
-        int x = Math.max(Math.min((int) (((ent.xPos + ent.width / 2) + boxMinX) / size), partionX - 1), 0);
-        int y = Math.max(Math.min((int) (((ent.yPos + ent.height / 2) + boxMinY) / size), partionY - 1), 0);
-        
-        Node n = ent.node;
-        if(n.x == x && n.y == y)
-        {
-            return;
-        }
-        
-        if(n.previous != null)
-        {
-            n.previous.next = n.next;
-        }
-        else
-        {
-            nodes[n.x][n.y] = n.next;
-        }
-        
-        if(n.next != null)
-        {
-            n.next.previous = n.previous;
-        }
-        
-        n.x = x;
-        n.y = y;
-        n.previous = null;
-        
-        if(nodes[x][y] == null)
-        {
-            nodes[x][y] = n;
-            n.next = null;
-        }
-        else
-        {
-            n.next = nodes[x][y];
-            nodes[x][y].previous = n;
-            nodes[x][y] = n;
-        }
-    }
-    
-    public List<T> getAllEntitiesAt(T not, double minX, double minY, double maxX, double maxY)
-    {
-        int sx = Math.max(Math.min((int) ((minX + boxMinX - maxWidth) / size), partionX - 1), 0);
-        int sy = Math.max(Math.min((int) ((minY + boxMinY - maxHeight) / size), partionY - 1), 0);
-        int ex = Math.max(Math.min((int) ((maxX + boxMinX + maxWidth) / size), partionX - 1), 0);
-        int ey = Math.max(Math.min((int) ((maxY + boxMinY + maxHeight) / size), partionY - 1), 0);
-        
-        List<T> list = new LinkedList<>();
-        
-        for(int x = sx; x <= ex; x++)
-        {
-            for(int y = sy; y <= ey; y++)
-            {
-                Node n = nodes[x][y];
-                while(n != null)
-                {
-                    if(not != entities[n.index] && entities[n.index].isColliding(minX, minY, maxX, maxY))
-                    {
-                        list.add(entities[n.index]);
-                    }
-                    n = n.next;
-                }
-            }
-        }
-        
-        return list;
-    } 
-    
-    public void forEach(Consumer<T> c)
-    {
-        isIterating = true;
-        for(int i = lastFreeEntity + 1; i < entities.length; i++)
-        {
-            c.accept(entities[i]);
-        }
-        isIterating = false;
-    }
-
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder();
-        for(T ent : entities)
-        {
-            sb.append(ent);
-            sb.append(", ");
-        }
-        return sb.toString();
-    }
-}

src/me/hammerle/snuviengine/game/Chat.java

@@ -1,139 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import me.hammerle.snuviengine.api.FontRenderer;
-import me.hammerle.snuviengine.api.Shader;
-
-public class Chat
-{
-    private final char[] input = new char[256];
-    private final StringBuilder[] chat = new StringBuilder[25];
-    private int startIndex = 0;
-    private int writeIndex = 0;
-    private int viewIndex = 0;
-    private int viewLenght = 5;
-    private final int lineLenght = 20;
-    
-    public Chat()
-    {
-        for(int i = 0; i < chat.length; i++)
-        {
-            chat[i] = new StringBuilder();
-        }
-        
-        for(int i = 0; i < 30; i++)
-        {
-            addString(String.valueOf(i).toCharArray());
-        }
-    }
-    
-    private void nextWriteIndex()
-    {
-        writeIndex = (writeIndex + 1) % chat.length;
-        chat[writeIndex].delete(0, chat[writeIndex].length());
-        if(writeIndex == startIndex)
-        {
-            startIndex = (startIndex + 1) % chat.length;
-        }
-        
-        int distance;
-        if(viewIndex < writeIndex)
-        {
-            distance = writeIndex - viewIndex;
-        }
-        else
-        {
-            distance = chat.length - viewIndex + writeIndex;
-        }
-        
-        if(distance - 1 == viewLenght)
-        {
-            viewIndex = (viewIndex + 1) % chat.length;
-        }
-    }
-    
-    private void addString(char[] text)
-    {
-        int pos = 0;
-        for(int i = 0; i < text.length; i++)
-        {
-            int j = i;
-            int w = 0;
-            OUTER: while(j < text.length)
-            {
-                switch(text[j])
-                {
-                    case ' ':
-                        break OUTER;
-                    case FontRenderer.COLOR_CHAR:
-                        j++;
-                        if(j < text.length)
-                        {
-                            j++;
-                        }   
-                        break;
-                    default:
-                        w++;
-                        j++;
-                        break;
-                }
-            }
-            
-            pos += w;
-            if(pos > lineLenght)
-            {
-                pos = w;
-                nextWriteIndex();
-            }
-            
-            while(i < j)
-            {
-                chat[writeIndex].append(text[i]);
-                i++;
-            }
-            pos++;
-            chat[writeIndex].append(' ');
-        }
-        nextWriteIndex();
-    }
-    
-    public void tick()
-    {
-        if(((Game.DOWN.getTime() + 15) & 0x7) == 0)
-        {
-            if((viewIndex + viewLenght) % chat.length != writeIndex)
-            {
-                viewIndex = (viewIndex + 1) % chat.length;
-            }
-        }
-        
-        if(((Game.UP.getTime() + 15) & 0x7) == 0)
-        {
-            if(viewIndex != startIndex)
-            {
-                viewIndex--;
-                if(viewIndex < 0)
-                {
-                    viewIndex += chat.length;
-                }
-            }
-        }
-    }
-    
-    public void renderTick()
-    {
-        Shader.setTextureEnabled(true);
-        Shader.setColorEnabled(true);
-        float x = 0.0f;
-        float y = 0.0f;
-        
-        FontRenderer fr = Shader.getFontRenderer();
-        
-        int i = viewIndex;
-        int end = (viewIndex + viewLenght) % chat.length;
-        while(i != end)
-        {
-            y = fr.drawString(x, y, true, chat[i].toString());
-            i = (i + 1) % chat.length;
-        }
-    }
-}

src/me/hammerle/snuviengine/game/Entity.java

@@ -1,265 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import java.util.List;
-import me.hammerle.snuviengine.api.Shader;
-import me.hammerle.snuviengine.game.BoxList.Node;
-import me.hammerle.snuviengine.util.Face;
-
-public class Entity implements IBoxListEntry
-{
-    private static final double STEP = 0.0625;
-    
-    public Game game;
-    
-    public double lastXPos;
-    public double lastYPos;
-    public double xPos;
-    public double yPos;
-    public double width;
-    public double height;
-    
-    public double vx = 0.0f;
-    public double vy = 0.0f;
-    
-    public Node node;
-    
-    public int counter = 0;
-    
-    public Entity(Game game, double width, double height)
-    {
-        this.game = game;
-        xPos = 0.0f;
-        yPos = 0.0f;
-        this.width = width;
-        this.height = height;
-        
-        vx = 1; //Math.random() * 8 + 5;
-        vy = 1; //Math.random() * 8 + 5;
-    }
-    
-    private boolean isColliding(Entity ent)
-    {
-        return xPos + width > ent.xPos && ent.xPos + ent.width > xPos &&
-                yPos + height > ent.yPos && ent.yPos + ent.height > yPos;
-    }
-    
-    @Override
-    public boolean isColliding(double minX, double minY, double maxX, double maxY)
-    {
-        return xPos + width > minX && maxX > xPos &&
-                yPos + height > minY && maxY > yPos;
-    }
-    
-    public void tick()
-    {
-        if(!(this instanceof Hero))
-        {
-            if(xPos < STEP)
-            {
-                vx = Math.abs(vx);
-            }
-            if(xPos + width > 400 - STEP)
-            {
-                vx = -Math.abs(vx);
-            }
-            if(yPos < STEP)
-            {
-                vy = Math.abs(vx);
-            }
-            if(yPos + height > 300 - STEP)
-            {
-                vy = -Math.abs(vx);
-            }
-        }
-        
-        lastXPos = xPos;
-        lastYPos = yPos;
-        
-        if(vx == 0.0 && vy == 0.0)
-        {
-            return;
-        }
-        
-        double lvx = vx;
-        double lvy = vy;
-              
-        List<Entity> list = game.entities.getAllEntitiesAt(this, 
-                xPos - STEP + ((vx < 0) ? vx : 0), 
-                yPos - STEP + ((vy < 0) ? vy : 0), 
-                xPos + STEP + width + ((vx > 0) ? vx : 0), 
-                yPos + STEP + height + ((vy > 0) ? vy : 0));
-        if(list.isEmpty())
-        {
-            xPos += vx;
-            yPos += vy;
-            
-            game.entities.update(this);
-            return;
-        }
-        
-        while(lvx != 0.0 || lvy != 0.0)
-        {
-            double oldXPos = xPos;
-            double oldYPos = yPos;
-            
-            if(lvx < 0.0)
-            {
-                if(lvx > -STEP)
-                {
-                    xPos += lvx;
-                    lvx = 0.0;
-                }
-                else
-                {
-                    xPos -= STEP;
-                    lvx += STEP;
-                }
-            }
-            else if(lvx > 0.0)
-            {
-                if(lvx < STEP)
-                {
-                    xPos += lvx;
-                    lvx = 0.0;
-                }
-                else
-                {
-                    xPos += STEP;
-                    lvx -= STEP;
-                }
-            }
-            
-            for(Entity ent : list)
-            {
-                if(this.isColliding(ent))
-                {
-                    lvx = 0.0f;
-                    xPos = oldXPos;
-                    break;
-                }
-            }
-            
-            if(lvy < 0.0)
-            {
-                if(lvy > -STEP)
-                {
-                    yPos += lvy;
-                    lvy = 0.0;
-                }
-                else
-                {
-                    yPos -= STEP;
-                    lvy += STEP;
-                }
-            }
-            else if(lvy > 0.0)
-            {
-                if(lvy < STEP)
-                {
-                    yPos += lvy;
-                    lvy = 0.0;
-                }
-                else
-                {
-                    yPos += STEP;
-                    lvy -= STEP;
-                }
-            }
-            
-            for(Entity ent : list)
-            {
-                if(this.isColliding(ent))
-                {
-                    lvy = 0.0f;
-                    yPos = oldYPos;
-                    break;
-                }
-            }
-        }
-        
-        game.entities.update(this);
-        
-        for(Face f : Face.values())
-        {
-            double minX = xPos + STEP * f.getOffsetX();
-            double minY = yPos + STEP * f.getOffsetY();
-            double maxX = minX + width;
-            double maxY = minY + height;
-            list.stream().filter(ent -> ent.isColliding(minX, minY, maxX, maxY))
-                    .forEach(ent -> onCollide(f, ent));
-        }
-    }
-    
-    public void onCollide(Face f, Entity ent)
-    {
-        switch(f)
-        {
-            case UP: 
-                vy = Math.abs(vy);
-                break;
-            case DOWN:
-                vy = -Math.abs(vy);
-                break;
-            case LEFT:
-                vx = Math.abs(vx);
-                break;
-            case RIGHT:
-                vx = -Math.abs(vx);
-                break;
-        }
-    }
-    
-    public void renderTick(float lag)
-    {
-        Shader.getColorRenderer().setDepth((float) yPos);
-        float x = (float) (lastXPos + (xPos - lastXPos) * lag);
-        float y = (float) (lastYPos + (yPos - lastYPos) * lag);
-        Shader.getColorRenderer().drawRectangle(x, y, (float) (x + width), (float) (y + height), 0x770000FF);
-    }
-    
-    public double getX()
-    {
-        return xPos;
-    }
-    
-    public double getY()
-    {
-        return yPos;
-    }
-    
-    public void setPosition(double x, double y)
-    {
-        xPos = x;
-        yPos = y;
-    }
-
-    @Override
-    public double getCenterX()
-    {
-        return xPos + width / 2;
-    }
-
-    @Override
-    public double getCenterY()
-    {
-        return yPos + height / 2;
-    }
-
-    @Override
-    public double getWidth()
-    {
-        return width;
-    }
-
-    @Override
-    public double getHeight()
-    {
-        return height;
-    }
-
-    @Override
-    public Node getNode()
-    {
-        return node;
-    }
-}

src/me/hammerle/snuviengine/game/Game.java

@@ -1,133 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import java.io.FileInputStream;
-import java.io.IOException;
-import me.hammerle.snuviengine.api.Engine;
-import me.hammerle.snuviengine.api.KeyBinding;
-import me.hammerle.snuviengine.api.KeyHandler;
-import me.hammerle.snuviengine.api.Shader;
-import me.hammerle.snuviengine.api.TextureRenderer;
-import me.hammerle.snuviengine.util.Clock;
-import me.hammerle.snuviengine.util.WrappedInputStream;
-import static org.lwjgl.glfw.GLFW.*;
-
-public class Game extends Engine
-{
-    public final static KeyBinding UP = KeyHandler.register(GLFW_KEY_UP);
-    public final static KeyBinding DOWN = KeyHandler.register(GLFW_KEY_DOWN);
-    public final static KeyBinding LEFT = KeyHandler.register(GLFW_KEY_LEFT);
-    public final static KeyBinding RIGHT = KeyHandler.register(GLFW_KEY_RIGHT);
-    
-    public final static KeyBinding KEY_F = KeyHandler.register(GLFW_KEY_F);
-    private boolean toogleFps = false;
-    public final static KeyBinding KEY_T = KeyHandler.register(GLFW_KEY_T);
-    private boolean toogleTps = false;
-    
-    private final TextureRenderer tr = new TextureRenderer(12);
-    
-    public BoxList<Entity> entities = new BoxList<>(5000, 0.0, 0.0, 400.0, 300.0, 1.0);
-    
-    private World w;
-    
-    public Game()
-    {
-        /*Random r = new Random(200);
-        for(int i = 0; i < 4096; i++)
-        {
-            Entity ent = new Entity(this, 2.0, 2.0);
-            ent.setPosition((int) (r.nextDouble() * 400.0), (int) (r.nextDouble() * 300));
-            ent.node = entities.add(ent);
-        }*/
-        
-        Hero hero = new Hero(this, 25.0, 25.0);
-        hero.setPosition(0.0, 0.0);
-        hero.node = entities.add(hero);
-        
-        w = new World(hero);
-        try
-        {
-            w.read(new WrappedInputStream(new FileInputStream("./testworld")));
-        }
-        catch(IOException ex)
-        {
-            ex.printStackTrace();
-        }
-    }
-    
-    @Override
-    public void init()
-    {
-        setNanosPerTick(50_000_000);
-        //setMaxFps(120);
-        
-        //Shader.setAmbientLight(0.5f, 0.5f, 0.5f);
-        Shader.setLightColor(0, 1f, 0.0f, 0.5f);
-        Shader.setLightStrength(0, 0.01f);
-        
-        
-        Shader.translateTo(0.0f, 0.0f);
-        Shader.updateMatrix();
-        Shader.setTextureEnabled(true);
-        Shader.setColorEnabled(true);
-    }
-
-    @Override
-    public void tick()
-    {        
-        /*w.tick();
-        CLOCK.start();
-        entities.forEach(ent -> ent.tick());
-        CLOCK.stop();
-        CLOCK.calculate();
-        
-        if(KEY_F.getTime() == 1)
-        {
-            toogleFps = !toogleFps;
-            setRenderFps(toogleFps);
-        }
-        if(KEY_T.getTime() == 1)
-        {
-            toogleTps = !toogleTps;
-            setRenderTps(toogleTps);
-        }*/
-    }
-    
-    private static final Clock CLOCK = new Clock(250);
-    
-    @Override
-    public void renderTick(float lag)
-    {
-        Shader.setLightEnabled(true);  
-        w.renderTick(lag);
-        
-        /*Shader.setTextureEnabled(false);
-        Shader.setColorEnabled(true);
-        Shader.getColorRenderer().drawRectangle(0, 299, 400, 300, 0xFFFFFFFF);
-        entities.forEach(ent -> ent.renderTick(lag));*/
-        
-        /*Shader.setTextureEnabled(true);
-        Shader.setColorEnabled(true);
-        Shader.translateTo(0.0f, 0.0f);
-        Shader.updateMatrix();*/
-        /*float y = 0;
-        for(int i = 0; i < 20; i++)
-        {
-            Shader.getFontRenderer().drawString(20, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            Shader.getFontRenderer().drawString(40, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            Shader.getFontRenderer().drawString(60, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            Shader.getFontRenderer().drawString(80, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            Shader.getFontRenderer().drawString(100, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            Shader.getFontRenderer().drawString(120, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-            y = Shader.getFontRenderer().drawString(30, y, true, "&aO&bO&cO&dO&eO&fO&gO&hO&iO&jO&kO&lO&mO&nO&oO&pO&qO&rO&sO&tO&uO&vO&wO&xO&yO&zO");
-        }
-        y = Shader.getFontRenderer().drawString(30, y, true, "FPS " + String.format("%.1f", getFps()));*/
-        //y = Shader.getFontRenderer().drawString(5, y, true, "TPS " + String.format("%.1f", getTps()));
-        //y = Shader.getFontRenderer().drawString(5, y, true, String.valueOf(CLOCK.getTime()));
-        //y = Shader.getFontRenderer().drawString(5, y, true, String.valueOf(CLOCK.getMinTime()));
-    }
-
-    @Override
-    public void onStop()
-    {
-    }
-}

src/me/hammerle/snuviengine/game/Hero.java

@@ -1,60 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import me.hammerle.snuviengine.api.Shader;
-import me.hammerle.snuviengine.util.Face;
-
-public class Hero extends Entity
-{
-    public Hero(Game game, double width, double height)
-    {
-        super(game, width, height);
-    }
-    
-    @Override
-    public void renderTick(float lag)
-    {
-        Shader.getColorRenderer().setDepth((float) yPos);
-        float x = (float) (lastXPos + (xPos - lastXPos) * lag);
-        float y = (float) (lastYPos + (yPos - lastYPos) * lag);
-        Shader.getColorRenderer().drawRectangle(x, y, (float) (x + width), (float) (y + height), 0xAAFF0000);
-    }
-
-    @Override
-    public void tick()
-    {
-        double nvx = 0.0;
-        double nvy = 0.0;
-        double speed = 5;
-        
-        if(Game.DOWN.isDown())
-        {
-            nvy += speed;
-        }
-        
-        if(Game.UP.isDown())
-        {
-            nvy -= speed;
-        }
-        
-        if(Game.LEFT.isDown())
-        {
-            nvx -= speed;
-        }
-        
-        if(Game.RIGHT.isDown())
-        {
-            nvx += speed;
-        }
-        
-        vx = nvx;
-        vy = nvy;
-        
-        super.tick();
-    }
-
-    @Override
-    public void onCollide(Face f, Entity ent)
-    {
-        
-    }
-}

src/me/hammerle/snuviengine/game/IBoxListEntry.java

@@ -1,13 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import me.hammerle.snuviengine.game.BoxList.Node;
-
-public interface IBoxListEntry
-{
-    public double getCenterX();
-    public double getCenterY();
-    public double getWidth();
-    public double getHeight();
-    public Node getNode();
-    public boolean isColliding(double minX, double minY, double maxX, double maxY);
-}

src/me/hammerle/snuviengine/game/World.java

@@ -1,134 +0,0 @@
-package me.hammerle.snuviengine.game;
-
-import java.io.IOException;
-import me.hammerle.snuviengine.api.Chunk;
-import me.hammerle.snuviengine.api.Shader;
-import me.hammerle.snuviengine.api.Texture;
-import me.hammerle.snuviengine.util.WrappedInputStream;
-import me.hammerle.snuviengine.util.WrappedOutputStream;
-
-public class World
-{
-    private int width;
-    private int height;
-    private Chunk[][] chunks;
-    
-    private final Texture tiles = new Texture("images/tileset-blackvolution.png");
-    
-    private final Hero h;
-    
-    private float cameraX = 0.0f;
-    private float cameraY = 0.0f;
-    private float lastCameraX = 0.0f;
-    private float lastCameraY = 0.0f;
-    
-    public World(Hero h)
-    {
-        this.h = h;
-    }
-    
-    public void read(WrappedInputStream in) throws IOException
-    {
-        width = in.readInt();
-        height = in.readInt();
-        if((width % Chunk.CHUNK_SIZE) != 0 || (height % Chunk.CHUNK_SIZE) != 0)
-        {
-            throw new IllegalArgumentException("world width and height must be a multiply of " + Chunk.CHUNK_SIZE);
-        }
-        chunks = new Chunk[width / Chunk.CHUNK_SIZE][height / Chunk.CHUNK_SIZE];
-        for(int x = 0; x < chunks.length; x++)
-        {
-            for(int y = 0; y < chunks[x].length; y++)
-            {
-                chunks[x][y] = new Chunk(x, y);
-                chunks[x][y].read(in);
-            }
-        }
-    }
-    
-    public void write(WrappedOutputStream out) throws IOException
-    {
-        out.writeInt(width);
-        out.writeInt(height);
-        for(Chunk[] chunk : chunks)
-        {
-            for(Chunk c : chunk)
-            {
-                c.write(out);
-            }
-        }
-    }
-    
-    public void tick()
-    {
-        h.tick();
-        lastCameraX = cameraX;
-        lastCameraY = cameraY;
-        cameraX = -getViewX((float) h.xPos);
-        cameraY = -getViewY((float) h.yPos);
-    }
-    
-    public void renderTick(float lag)
-    {
-        Shader.translateTo(lastCameraX + (cameraX - lastCameraX) * lag, lastCameraY + (cameraY - lastCameraY) * lag);
-        
-        Shader.setLightLocation(0, 100 + lastCameraX + (cameraX - lastCameraX) * lag, 100 + lastCameraY + (cameraY - lastCameraY) * lag);
-        
-        Shader.setColorEnabled(false);
-        Shader.setTextureEnabled(true);
-        tiles.bind();
-        for(Chunk[] chunk : chunks)
-        {
-            for(Chunk c : chunk)
-            {
-                c.drawBackground();
-            }
-        }
-        
-        Shader.updateMatrix();
-        Shader.setColorEnabled(true);
-        Shader.setTextureEnabled(false);
-        h.renderTick(lag);
-        
-        Shader.setColorEnabled(false);
-        Shader.setTextureEnabled(true);
-        tiles.bind();
-        for(Chunk[] chunk : chunks)
-        {
-            for(Chunk c : chunk)
-            {
-                c.drawForeground();
-            }
-        }
-    }
-    
-    private float getViewX(float x) 
-    {
-        x -= Shader.getViewWidth() >> 1;
-        if(x < 0)
-        {
-            return 0;
-        }
-        float max = width * Chunk.TILE_SIZE - Shader.getViewWidth();
-        if(x > max)
-        {
-            return max;
-        }
-        return x;
-    }
-    
-    private float getViewY(float y) 
-    {
-        y -= Shader.getViewHeight() >> 1;
-        if(y < 0)
-        {
-            return 0;
-        }
-        float max = height * Chunk.TILE_SIZE - Shader.getViewHeight();
-        if(y > max)
-        {
-            return max;
-        }
-        return y;
-    }
-}

src/me/hammerle/snuviengine/util/Clock.java

@@ -1,68 +0,0 @@
-package me.hammerle.snuviengine.util;
-
-public class Clock
-{
-    private final int dataLength;
-    private final long[] data;
-    private int index = 0;
-    private long sum = 0;
-    private long time;
-    private boolean stable = false;
-    
-    private long min = Long.MAX_VALUE;
-    private long avg = - 1;
-    
-    public Clock(int dataLength)
-    {
-        this.dataLength = dataLength;
-        data = new long[dataLength];
-    }
-    
-    public void start()
-    {
-        time = System.nanoTime();
-    }
-    
-    public void stop()
-    {
-        time = System.nanoTime() - time;
-        sum -= data[index];
-        sum += time;
-        data[index] = time;
-        index = (index + 1) % dataLength;
-        if(index == 0)
-        {
-            stable = true;
-        }
-    }
-    
-    public void calculate()
-    {
-        if(stable)
-        {
-            avg = sum / dataLength;
-            if(avg < min)
-            {
-                min = avg;
-            }
-        }
-    }
-    
-    public long getTime()
-    {
-        if(stable)
-        {
-            return avg;
-        }
-        return -1;
-    }
-    
-    public long getMinTime()
-    {
-        if(stable)
-        {
-            return min;
-        }
-        return -1;
-    }
-}

src/me/hammerle/snuviengine/util/Face.java

@@ -1,28 +0,0 @@
-package me.hammerle.snuviengine.util;
-
-public enum Face
-{
-    LEFT(-1, 0), 
-    RIGHT(1, 0), 
-    UP(0, -1), 
-    DOWN(0, 1);
-    
-    private final int offsetX;
-    private final int offsetY;
-    
-    Face(int offsetX, int offsetY)
-    {
-        this.offsetX = offsetX;
-        this.offsetY = offsetY;
-    }
-
-    public int getOffsetX()
-    {
-        return offsetX;
-    }
-
-    public int getOffsetY()
-    {
-        return offsetY;
-    }
-}

src/me/hammerle/snuviengine/util/WrappedInputStream.java

@@ -1,60 +0,0 @@
-package me.hammerle.snuviengine.util;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-public class WrappedInputStream
-{
-    private final InputStream in;
-    
-    public WrappedInputStream(InputStream in)
-    {
-        this.in = in;
-    }
-    
-    private int read() throws IOException
-    {
-        int i = in.read();
-        if(i == -1)
-        {
-            throw new IOException("end of stream");
-        }
-        return i;
-    }
-    
-    public byte readByte() throws IOException
-    {
-        return (byte) read();
-    }
-    
-    public int readUnsignedByte() throws IOException
-    {
-        return read();
-    }
-    
-    public short readShort() throws IOException
-    {
-        return (short) (read() | (read() << 8));
-    }
-    
-    public int readInt() throws IOException
-    {
-        return read() | (read() << 8) | (read() << 16) | (read() << 24);
-    }
-    
-    public long readLong() throws IOException
-    {
-        return ((long) read()) | (((long) read()) << 8) | (((long) read()) << 16) | (((long) read()) << 24) | 
-                (((long) read()) << 32) | (((long) read()) << 40) | (((long) read()) << 48) | (((long) read()) << 56);
-    }
-    
-    public String readString() throws IOException
-    {
-        byte[] b = new byte[readInt()];
-        for(int i = 0; i < b.length; i++)
-        {
-            b[i] = (byte) read();
-        }
-        return new String(b);
-    }
-}

src/me/hammerle/snuviengine/util/WrappedOutputStream.java

@@ -1,57 +0,0 @@
-package me.hammerle.snuviengine.util;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-public class WrappedOutputStream
-{
-    private final OutputStream out;
-    
-    public WrappedOutputStream(OutputStream out)
-    {
-        this.out = out;
-    }
-    
-    public void writeByte(int b) throws IOException
-    {
-        out.write(b);
-    }
-    
-    public void writeUnsignedByte(int b) throws IOException
-    {
-        out.write(b);
-    }
-    
-    public void writeShort(int s) throws IOException
-    {
-        out.write(s & 0xFF);
-        out.write((s >> 8) & 0xFF);
-    }
-    
-    public void writeInt(int i) throws IOException
-    {
-        out.write(i & 0xFF);
-        out.write((i >> 8) & 0xFF);
-        out.write((i >> 16) & 0xFF);
-        out.write((i >> 24) & 0xFF);
-    }
-    
-    public void writeLong(long l) throws IOException
-    {
-        out.write((int) (l & 0xFF));
-        out.write((int) ((l >> 8) & 0xFF));
-        out.write((int) ((l >> 16) & 0xFF));
-        out.write((int) ((l >> 24) & 0xFF));
-        out.write((int) ((l >> 32) & 0xFF));
-        out.write((int) ((l >> 40) & 0xFF));
-        out.write((int) ((l >> 48) & 0xFF));
-        out.write((int) ((l >> 56) & 0xFF));
-    }
-    
-    public void writeString(String s) throws IOException
-    {
-        byte[] b = s.getBytes();
-        writeInt(b.length);
-        out.write(b);
-    }
-}