init

.gitignore

@@ -0,0 +1,5 @@
+/nbproject
+/build
+/dist
+/images
+build.xml

manifest.mf

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+X-COMMENT: Main-Class will be added automatically by build
+

shaders/fragment.fs

@@ -0,0 +1,61 @@
+#version 430
+
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec2 tex;
+layout (location = 2) in vec4 vertexColor;
+
+layout (binding = 0) uniform sampler2D samp;
+
+uniform mat4 matrix;
+uniform vec2 camera;
+uniform float depth;
+uniform vec3 ambientLight;
+
+struct Light 
+{
+    vec2 pos;
+    float strength;
+    vec3 color;
+}; 
+
+uniform Light lights[32];
+
+uniform bool useTexture;
+uniform bool useLight;
+uniform bool useCameraOffset;
+
+in vec2 tc;
+in vec2 loc;
+in vec4 vColor;
+out vec4 color;
+
+vec4 getLight()
+{
+    vec3 light = vec3(0, 0, 0);
+    for(int i = 0; i < 32; i++)
+    {
+        light += lights[i].color * max(1 - lights[i].strength * length(loc - lights[i].pos), 0);
+    }
+    return vec4(min(light, vec3(1, 1, 1)), 1);
+}
+
+void main(void)
+{
+    if(useTexture)
+    {
+        color = texture(samp, tc);
+        if(color.a != 1.0)
+        {
+            discard;
+        }
+    }
+    else
+    {
+        color = vColor;
+    }
+
+    if(useLight)
+    {
+        color = pow(pow(color, vec4(1 / 2.2)) * vec4(ambientLight, 1.0) + getLight(), vec4(2.2));
+    }
+}

shaders/vertex.vs

@@ -0,0 +1,46 @@
+#version 430
+
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec2 tex;
+layout (location = 2) in vec4 vertexColor;
+
+layout (binding = 0) uniform sampler2D samp;
+
+uniform mat4 matrix;
+uniform vec2 camera;
+uniform float depth;
+uniform vec3 ambientLight;
+
+struct Light 
+{
+    vec2 pos;
+    float strength;
+    vec3 color;
+}; 
+
+uniform Light lights[32];
+
+uniform bool useTexture;
+uniform bool useLight;
+uniform bool useCameraOffset;
+
+out vec2 tc;
+out vec2 loc;
+out vec4 vColor;
+
+void main(void)
+{ 
+    loc = pos;
+
+    if(useCameraOffset)
+    {
+        gl_Position = matrix * vec4(pos - camera, depth, 1.0);
+    }
+    else
+    {
+        gl_Position = matrix * vec4(pos, depth, 1.0);
+    }
+
+    tc = tex;
+    vColor = vertexColor;
+}

src/me/hammerle/snuviengine/Main.java

@@ -0,0 +1,47 @@
+package me.hammerle.snuviengine;
+
+import me.hammerle.snuviengine.game.Game;
+
+public class Main 
+{
+    public static void main(String[] args)
+    {
+        Game game = new Game();
+        game.run();
+        
+        //for(int i = 0; i < 736; i++)
+        //{
+        //    System.out.println("public static final TexturedTile OUT_" + i + " = register(" + i + ", new TexturedTile(\"out" + i + ".png\"));");
+        //}
+        
+        /*
+        try
+        {
+            BufferedImage image = ImageIO.read(new File("tileset-blackvolution.png"));
+            int w = image.getWidth();
+            int h = image.getHeight();
+            int counter = 0;
+            
+            for(int iy = 0; iy < h; iy += 16)
+            {
+                for(int ix = 0; ix < w; ix += 16)
+                {
+                    BufferedImage out = new BufferedImage(16, 16, 2);
+                    for(int x = 0; x < 16; x++)
+                    {
+                        for(int y = 0; y < 16; y++)
+                        {
+                            out.setRGB(x, y, image.getRGB(x + ix, y + iy));
+                        }
+                    }
+                    ImageIO.write(out, "png", new File("images/out" + counter + ".png"));
+                    counter++;
+                }
+            }
+        }
+        catch(Exception ex)
+        {
+            ex.printStackTrace();
+        }*/
+    }
+}

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

@@ -0,0 +1,118 @@
+package me.hammerle.snuviengine.api;
+
+import java.nio.FloatBuffer;
+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
+{
+    private final int vao;
+    private final int vbo;
+    private boolean dirty = true;
+    private final FloatBuffer buffer = BufferUtils.createFloatBuffer(Map.PARTION * Map.PARTION * 24);
+    
+    protected Chunk()
+    {
+        vao = glGenVertexArrays();
+        vbo = glGenBuffers();
+        
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        
+        glEnableVertexAttribArray(0);
+        glVertexAttribPointer(0, 2, GL_FLOAT, false, 16, 0);
+        
+        glEnableVertexAttribArray(1);  
+        glVertexAttribPointer(1, 2, GL_FLOAT, false, 16, 8);
+    }
+    
+    protected void delete()
+    {
+        glDeleteVertexArrays(vao);
+        glDeleteBuffers(vbo);
+    }
+    
+    private void build(short[][] data, int sx, int sy, TextureAtlas atlas)
+    {
+        dirty = false;
+        float f = Engine.TILE_SIZE * Engine.SCALE;
+        float t = 1.0f / 2048.0f;
+        
+        for(int x = sx; x < sx + Map.PARTION; x++)
+        {
+            for(int y = sy; y < sy + Map.PARTION; y++)
+            {
+                if(data[x][y] == -1)
+                {
+                    for(int i = 0; i < 24; i++)
+                    {
+                        buffer.put(-1.0f);
+                    }
+                }
+                else
+                {
+                    float minX = atlas.getTextureMinX(data[x][y], false) + t;
+                    float minY = atlas.getTextureMinY(data[x][y], false) + t;
+                    float maxX = atlas.getTextureMaxX(data[x][y], false) - t;
+                    float maxY = atlas.getTextureMaxY(data[x][y], false) - t;
+
+                    buffer.put(x * f);
+                    buffer.put((y + 1) * f);
+
+                    buffer.put(minX);
+                    buffer.put(maxY);
+
+                    buffer.put(x * f);
+                    buffer.put(y * f);
+
+                    buffer.put(minX);
+                    buffer.put(minY);
+
+                    buffer.put((x + 1) * f);
+                    buffer.put((y + 1) * f);
+
+                    buffer.put(maxX);
+                    buffer.put(maxY);
+
+                    buffer.put((x + 1) * f);
+                    buffer.put((y + 1) * f);
+
+                    buffer.put(maxX);
+                    buffer.put(maxY);
+
+                    buffer.put(x * f);
+                    buffer.put(y * f);
+
+                    buffer.put(minX);
+                    buffer.put(minY);
+
+                    buffer.put((x + 1) * f);
+                    buffer.put(y * f);
+
+                    buffer.put(maxX);
+                    buffer.put(minY);
+                }
+            }
+        }
+        
+        buffer.flip();
+        
+        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
+    }
+    
+    protected void draw(short[][] data, int sx, int sy, TextureAtlas atlas)
+    {
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        
+        if(dirty)
+        {
+            build(data, sx, sy, atlas);            
+        }
+        
+        glDrawArrays(GL_TRIANGLES, 0, Map.PARTION * Map.PARTION * 6);
+    }
+}

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

@@ -0,0 +1,111 @@
+package me.hammerle.snuviengine.api;
+
+import java.nio.FloatBuffer;
+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 ColorRenderer
+{
+    private int vao;
+    private int vbo;
+    
+    private float r = 0.0f;
+    private float g = 0.0f;
+    private float b = 0.0f;
+    private float a = 0.0f;
+    
+    private FloatBuffer buffer = BufferUtils.createFloatBuffer(18);
+    
+    private boolean built = false;
+    
+    public ColorRenderer()
+    {
+        Shader.addTask(() -> 
+        {
+            vao = glGenVertexArrays();
+            vbo = glGenBuffers();
+
+            glBindVertexArray(vao);
+            glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+            glEnableVertexAttribArray(0);
+            glVertexAttribPointer(0, 2, GL_FLOAT, false, 24, 0);
+
+            glEnableVertexAttribArray(2);  
+            glVertexAttribPointer(2, 4, GL_FLOAT, false, 24, 8);
+        });
+    }
+    
+    public void setColor(float r, float g, float b, float a)
+    {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+    
+    public void addTriangle(float x1, float y1, float x2, float y2, float x3, float y3)
+    {
+        if(buffer.position() + 18 > buffer.capacity())
+        {
+            FloatBuffer newBuffer = BufferUtils.createFloatBuffer(buffer.capacity() * 2);
+            buffer.flip();
+            newBuffer.put(buffer);
+            buffer = newBuffer;
+        }
+        
+        buffer.put(x1);
+        buffer.put(y1);        
+        buffer.put(r);
+        buffer.put(g);
+        buffer.put(b);
+        buffer.put(a);
+        
+        buffer.put(x2);
+        buffer.put(y2);        
+        buffer.put(r);
+        buffer.put(g);
+        buffer.put(b);
+        buffer.put(a);
+        
+        buffer.put(x3);
+        buffer.put(y3);        
+        buffer.put(r);
+        buffer.put(g);
+        buffer.put(b);
+        buffer.put(a);
+    }
+    
+    public void addRectangle(float minX, float minY, float maxX, float maxY)
+    {
+        addTriangle(minX, maxY, minX, minY, maxX, maxY);
+        addTriangle(maxX, maxY, minX, minY, maxX, minY);
+    }
+    
+    public void build()
+    {
+        if(!Shader.initDone || buffer.position() == 0)
+        {
+            throw new ShaderException("build called too early");
+        }
+        buffer.flip();
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
+        built = true;
+    }
+    
+    public void draw()
+    {
+        if(!built)
+        {
+            throw new ShaderException("build must be called before drawing");
+        }
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glDrawArrays(GL_TRIANGLES, 0, buffer.limit() / 6);
+    }
+}

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

@@ -0,0 +1,159 @@
+package me.hammerle.snuviengine.api;
+
+import org.lwjgl.glfw.*;
+import org.lwjgl.opengl.*;
+import static org.lwjgl.glfw.Callbacks.*;
+import static org.lwjgl.glfw.GLFW.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+public abstract class Engine
+{
+    private static final String VERSION = "0.0.1";
+    public static final int WIDTH = 1024;
+    public static final int HEIGHT = 576;
+    public static final int TILE_SIZE = 16;
+    public static final float SCALE = 2.0f;
+    
+    private long window;
+    
+    private int fpsIndex = 0;
+    private final long[] fps = new long[100];
+    private long fpsSum = 0;
+    private double currentFps = 0;
+    
+    private int tpsIndex = 0;
+    private final long[] tps = new long[100];
+    private long tpsSum = 0;
+    private double currentTps = 0;
+    
+    private long nanosPerTick = 10_000_000;
+    
+    public Engine()
+    {
+    }    
+    
+    public final void run()
+    {
+        initGLFW();
+        loop();
+
+        glfwFreeCallbacks(window);
+        glfwDestroyWindow(window);
+
+        glfwTerminate();
+        GLFWErrorCallback error = glfwSetErrorCallback(null);
+        if(error != null)
+        {
+            error.free();
+        }
+    }
+
+    private void initGLFW()
+    {
+        GLFWErrorCallback.createPrint(System.err).set();
+        
+        if(!glfwInit())
+        {
+            throw new IllegalStateException("Unable to initialize GLFW");
+        }
+
+        glfwDefaultWindowHints();
+        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
+        glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+
+        window = glfwCreateWindow(WIDTH, HEIGHT, "SnuviEngine " + VERSION, NULL, NULL);
+        if(window == NULL)
+        {
+            throw new RuntimeException("Failed to create the GLFW window");
+        }
+
+        glfwSetKeyCallback(window, (w, key, scancode, action, mods) -> 
+        {
+            if(action == GLFW_RELEASE)
+            {
+                KeyHandler.onKeyUpEvent(key);
+                if(key == GLFW_KEY_ESCAPE)
+                {
+                    glfwSetWindowShouldClose(window, true);
+                }
+            }
+            else if(action == GLFW_PRESS)
+            {
+                KeyHandler.onKeyDownEvent(key);
+            }
+        });
+        
+        glfwSetFramebufferSizeCallback(window, (w, fwidth, fheight) -> 
+        {
+            glViewport(0, 0, fwidth, fheight);
+        });
+        
+        glfwSetWindowAspectRatio(window, 16, 9);
+        
+        glfwMakeContextCurrent(window);
+        glfwSwapInterval(1);
+       
+        glfwShowWindow(window);
+    }
+
+    private void loop()
+    {
+        GL.createCapabilities();
+        
+        long lastFrame = System.nanoTime();
+        long lastTick = System.nanoTime();
+        long time;
+        long lag = 0;
+        
+        Shader.init();
+        init();
+        
+        while(!glfwWindowShouldClose(window))
+        {
+            glfwSwapBuffers(window);
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+            time = System.nanoTime();
+            fpsSum -= fps[fpsIndex];
+            fps[fpsIndex] = time - lastFrame;
+            fpsSum += fps[fpsIndex];
+            fpsIndex = (fpsIndex + 1) % fps.length;
+            lag += fps[fpsIndex];
+            lastFrame = time;
+            currentFps = (1_000_000_000.0 * fps.length) / fpsSum;
+            
+            while(lag >= nanosPerTick)
+            {
+                lag -= nanosPerTick;
+                
+                time = System.nanoTime();
+                tpsSum -= tps[tpsIndex];
+                tps[tpsIndex] = time - lastTick;
+                tpsSum += tps[tpsIndex];
+                tpsIndex = (tpsIndex + 1) % tps.length;
+                lastTick = time;
+                currentTps = (1_000_000_000.0 * tps.length) / tpsSum;
+                
+                KeyHandler.tick();
+                tick();
+            }
+            
+            Shader.doTasks();
+            renderTick();
+
+            glfwPollEvents();
+        }
+    }
+    
+    public final void setNanosPerTick(long nanos)
+    {
+        nanosPerTick = nanos;
+    }
+    
+    public abstract void init();
+    public abstract void tick();
+    public abstract void renderTick();
+}
+
+

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

@@ -0,0 +1,67 @@
+package me.hammerle.snuviengine.api;
+
+public final class KeyBinding
+{
+    private boolean isDown;
+    private int time;
+    private boolean isReleased;
+    
+    protected KeyBinding()
+    {
+        isDown = false;
+        time = 0;
+        isReleased = false;
+    }
+    
+    protected void onKeyDownEvent()
+    {
+        isDown = true;
+    }
+    
+    protected void onKeyUpEvent()
+    {
+        isReleased = true;
+    }
+    
+    protected void tick()
+    {   
+        if(isDown)
+        {
+            time++;
+            if(isReleased)
+            {
+                isDown = false;
+            }
+        }
+        else if(isReleased)
+        {
+            isReleased = false;
+            time = 0;
+        }
+    }
+    
+    public boolean isReleased()
+    {
+        return isReleased;
+    }
+    
+    public boolean isUp()
+    {
+        return !isDown;
+    }
+    
+    public boolean isDown()
+    {
+        return isDown;
+    }
+    
+    public int getTime()
+    {
+        return time;
+    }
+    
+    public void setTime(int time)
+    {
+        this.time = time;
+    }
+}

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

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

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

@@ -0,0 +1,41 @@
+package me.hammerle.snuviengine.api;
+
+import java.util.HashMap;
+
+public final class KeyHandler
+{
+    private final static HashMap<Integer, KeyBinding> BINDINGS = new HashMap<>();
+    
+    public static KeyBinding register(int key) throws KeyDuplicateException
+    {
+        KeyBinding binding = new KeyBinding();
+        if(BINDINGS.putIfAbsent(key, binding) != null)
+        {
+            throw new KeyDuplicateException("the key '" + key + "' has already been registered");
+        }
+        return binding;
+    }
+
+    protected static void onKeyDownEvent(int key) 
+    {
+        KeyBinding binding = BINDINGS.get(key);
+        if(binding != null)
+        {
+            binding.onKeyDownEvent();
+        }
+    }
+
+    protected static void onKeyUpEvent(int key) 
+    {
+        KeyBinding binding = BINDINGS.get(key);
+        if(binding != null)
+        {
+            binding.onKeyUpEvent();
+        }
+    }
+    
+    protected static void tick()
+    {
+        BINDINGS.values().forEach(binding -> binding.tick());
+    }
+}

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

@@ -0,0 +1,173 @@
+package me.hammerle.snuviengine.api;
+
+import java.util.Random;
+import static org.lwjgl.opengl.GL20.*;
+
+public class Map 
+{
+    protected final static int PARTION = 16;
+    
+    private final TextureAtlas textures = new TextureAtlas(Engine.TILE_SIZE, Engine.TILE_SIZE, 16, 16);
+    
+    private int layers;
+    private int width;
+    private int height;
+    private short[][][] tiles;
+    
+    private int pWidth;
+    private int pHeight;
+    private Chunk[][][] chunks = null;
+    
+    private float cameraX;
+    private float cameraY;
+    private boolean dirtyCamera = true;
+    
+    protected Map()
+    {
+    }
+    
+    protected void preInit()
+    {
+    }
+    
+    protected void postInit()
+    {
+        textures.generateTexture();
+    }
+    
+    protected void bind(int program)
+    {
+        
+        dirtyCamera = true;
+        tick(program);
+    }
+    
+    protected void tick(int program)
+    {
+        
+        if(dirtyCamera)
+        {
+            dirtyCamera = false;
+            glUniform2f(glGetUniformLocation(program, "camera"), cameraX, cameraY);
+        }
+    }
+    
+    public TextureAtlas getTextureAtlas()
+    {
+        return textures;
+    }
+    
+    public void load(String path)
+    {
+        layers = 2;
+        width = 64;
+        height = 64;
+        tiles = new short[layers][width][height];
+        Random r = new Random(100);
+        for(int x = 0; x < width; x++)
+        {
+            for(int y = 0; y < height; y++)
+            {
+                tiles[0][x][y] = 0;
+            }
+        }
+        for(int x = 0; x < width; x++)
+        {
+            for(int y = 0; y < height; y++)
+            {
+                tiles[1][x][y] = (short) (r.nextInt(2));
+            }
+        }
+        
+        if(chunks != null)
+        {
+            for(Chunk[][] a : chunks)
+            {
+                for(Chunk[] b : a)
+                {
+                    for(Chunk c : b)
+                    {
+                        c.delete();
+                    }
+                }
+            }
+        }
+        
+        pWidth = width / PARTION;
+        pHeight = height / PARTION;
+        
+        chunks = new Chunk[layers][pWidth][pHeight];
+        for(int l = 0; l < layers; l++)
+        {
+            for(int x = 0; x < pWidth; x++)
+            {
+                for(int y = 0; y < pHeight; y++)
+                {
+                    chunks[l][x][y] = new Chunk();
+                }
+            }
+        }
+    }
+    
+    protected void draw()
+    {
+        textures.bindTexture();
+        for(int l = 0; l < layers; l++)
+        {
+            for(int x = 0; x < pWidth; x++)
+            {
+                for(int y = 0; y < pHeight; y++)
+                {
+                    chunks[l][x][y].draw(tiles[l], x * PARTION, y * PARTION, textures);
+                }
+            }
+        }
+    }
+    
+    public void setCamera(float x, float y)
+    {
+        cameraX = getViewX(x);
+        cameraY = getViewY(y);
+        dirtyCamera = true;
+    }
+    
+    public float getCameraX()
+    {
+        return cameraX;
+    }
+    
+    public float getCameraY()
+    {
+        return cameraY;
+    }
+    
+    private float getViewX(float x) 
+    {
+        x -= Engine.WIDTH >> 1;
+        if(x < 0)
+        {
+            return 0;
+        }
+        float max = width * Engine.TILE_SIZE * Engine.SCALE - Engine.WIDTH;
+        if(x > max)
+        {
+            return max;
+        }
+        return x;
+    }
+    
+    private float getViewY(float y) 
+    {
+        y -= Engine.HEIGHT >> 1;
+        if(y < 0)
+        {
+            return 0;
+        }
+        float max = height * Engine.TILE_SIZE * Engine.SCALE - Engine.HEIGHT;
+        if(y > max)
+        {
+            return max;
+        }
+        return y;
+    }
+}

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

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

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

@@ -0,0 +1,256 @@
+package me.hammerle.snuviengine.api;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.FloatBuffer;
+import java.nio.file.Files;
+import java.util.LinkedList;
+import java.util.List;
+import org.lwjgl.BufferUtils;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL20.*;
+
+public final class Shader
+{
+    private static int program = -1;
+    private static String[][] lightStrings;
+    
+    private static final List<Runnable> TASKS = new LinkedList<>();
+    
+    protected static boolean initDone = false;
+    
+    protected static void init()
+    {
+        program = createShaderProgram("shaders/vertex.vs", "shaders/fragment.fs");
+        glUseProgram(program);
+        
+        sendMatrix();
+        setCamera(0.0f, 0.0f);
+        setDepth(0.0f);
+        setAmbientLight(1.0f, 1.0f, 1.0f);
+        
+        lightStrings = new String[32][3];
+        for(int index = 0; index < lightStrings.length; index++)
+        {
+            lightStrings[index][0] = "lights[" + index + "].color";
+            lightStrings[index][1] = "lights[" + index + "].pos";
+            lightStrings[index][2] = "lights[" + index + "].strength";
+            
+            setLightColor(index, 0.0f, 0.0f, 0.0f);
+            setLightLocation(index, 0.0f, 0.0f);
+            setLightStrength(index, 0.0f);
+        }
+        
+        setTextureUsing(false);
+        setLightUsing(false);
+        setCameraUsing(false);
+        
+        initDone = true;
+    }
+    
+    protected static void addTask(Runnable r)
+    {
+        TASKS.add(r);
+    }
+    
+    protected static void doTasks()
+    {
+        if(!TASKS.isEmpty())
+        {
+            TASKS.forEach(r -> r.run());
+            TASKS.clear();
+        }
+    }
+    
+    private static void sendMatrix()
+    {
+        FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
+        
+        buffer.put(2.0f / Engine.WIDTH);
+        buffer.put(0.0f);
+        buffer.put(0.0f);
+        buffer.put(0.0f);
+        
+        buffer.put(0.0f);
+        buffer.put(2.0f / Engine.HEIGHT);
+        buffer.put(0.0f);
+        buffer.put(0.0f);
+        
+        buffer.put(0.0f);
+        buffer.put(0.0f);
+        buffer.put(1.0f);
+        buffer.put(0.0f);
+        
+        buffer.put(-1.0f);
+        buffer.put(-1.0f);
+        buffer.put(0.0f);
+        buffer.put(1.0f);
+        
+        buffer.flip();
+        
+        glUniformMatrix4fv(glGetUniformLocation(program, "matrix"), false, buffer);
+    }
+    
+    public static void setCamera(float x, float y)
+    {
+        glUniform2f(glGetUniformLocation(program, "camera"), x, y);
+    }
+    
+    public static void setDepth(float depth)
+    {
+        glUniform1f(glGetUniformLocation(program, "depth"), depth);
+    }
+    
+    public static void setAmbientLight(float r, float g, float b)
+    {
+        glUniform3f(glGetUniformLocation(program, "ambientLight"), r, g, b);
+    }
+    
+    private static void checkLightIndex(int index)
+    {
+        if(index < 0 || index > lightStrings.length)
+        {
+            throw new ShaderException("'" + index + "' is not a valid light index");
+        }
+    }
+    
+    public static void setLightColor(int index, float r, float g, float b)
+    {
+        checkLightIndex(index);
+        glUniform3f(glGetUniformLocation(program, lightStrings[index][0]), r, g, b);
+    }
+    
+    public static void setLightLocation(int index, float x, float y)
+    {
+        checkLightIndex(index);
+        glUniform2f(glGetUniformLocation(program, lightStrings[index][1]), x, y);
+    }
+    
+    public static void setLightStrength(int index, float strength)
+    {
+        checkLightIndex(index);
+        glUniform1f(glGetUniformLocation(program, lightStrings[index][2]), strength);
+    }
+    
+    public static void setTextureUsing(boolean use)
+    {
+        glUniform1i(glGetUniformLocation(program, "useTexture"), use ? 1 : 0);
+    }
+    
+    public static void setLightUsing(boolean use)
+    {
+        glUniform1i(glGetUniformLocation(program, "useLight"), use ? 1 : 0);
+    }
+    
+    public static void setCameraUsing(boolean use)
+    {
+        glUniform1i(glGetUniformLocation(program, "useCameraOffset"), use ? 1 : 0);
+    }
+    
+    // -------------------------------------------------------------------------
+    // general stuff
+    // -------------------------------------------------------------------------
+    
+    private static String[] readFile(String path)
+    {
+        try
+        {
+            File f = new File(path);
+            List<String> list = Files.readAllLines(f.toPath());
+            list.replaceAll(s -> s + "\n");
+            return list.toArray(new String[list.size()]);
+        }
+        catch(IOException ex)
+        {
+            throw new ShaderException("failed reading shader file '" + path + "'");
+        }
+    }
+    
+    private static String getError()
+    {
+        StringBuilder sb = new StringBuilder();
+        
+        int glErr = glGetError();
+        while(glErr != GL_NO_ERROR)
+        {
+            sb.append(glErr);
+            sb.append(" ");
+            glErr = glGetError();
+        }
+        
+        return sb.toString();
+    }
+    
+    private static int createShaderProgram(String vertex, String fragment)
+    {
+        // ---------------------------------------------------------------------
+        // vertex shader
+        // ---------------------------------------------------------------------
+        
+        String vShaderSource[] = readFile(vertex);
+        
+        int vShader = glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(vShader, vShaderSource);
+        glCompileShader(vShader);
+
+        String error = getError();
+        if(!error.isEmpty())
+        {
+            throw new ShaderException("failed compiling vertex shader '" + vertex + "' " + error);
+        }
+        
+        int compiled = glGetShaderi(vShader, GL_COMPILE_STATUS);
+        if(compiled != 1)
+        {
+            throw new ShaderException("failed compiling vertex shader '" + vertex + "' " + compiled + " " + glGetShaderInfoLog(vShader));
+        }
+        
+        // ---------------------------------------------------------------------
+        // fragment shader
+        // ---------------------------------------------------------------------
+
+        String fShaderSource[] = readFile(fragment);
+        
+        int fShader = glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(fShader, fShaderSource);
+        glCompileShader(fShader);
+
+        error = getError();
+        if(!error.isEmpty())
+        {
+            throw new ShaderException("failed compiling fragment shader '" + fragment + "' " + error);
+        }
+        
+        compiled = glGetShaderi(fShader, GL_COMPILE_STATUS);
+        if(compiled != 1)
+        {
+            throw new ShaderException("failed compiling fragment shader '" + fragment + "' " + compiled + " " + glGetShaderInfoLog(fShader));
+        }
+        
+        // ---------------------------------------------------------------------
+        // linking
+        // ---------------------------------------------------------------------
+
+        int vfprogram = glCreateProgram();
+        glAttachShader(vfprogram, vShader);
+        glAttachShader(vfprogram, fShader);
+        glLinkProgram(vfprogram);
+
+        error = getError();
+        if(!error.isEmpty())
+        {
+            throw new ShaderException("failed linking shaders '" + vertex + "' and '" + fragment + "' " + error);
+        }
+        
+        compiled = glGetProgrami(vfprogram, GL_LINK_STATUS);
+        if(compiled != 1)
+        {
+            throw new ShaderException("failed linking shaders '" + vertex + "' and '" + fragment + "' " + compiled);
+        }
+
+        glDeleteShader(vShader);
+        glDeleteShader(fShader);
+        
+        return vfprogram;
+    }  
+}

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

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

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

@@ -0,0 +1,153 @@
+package me.hammerle.snuviengine.api;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.IntBuffer;
+import java.util.LinkedList;
+import java.util.List;
+import javax.imageio.ImageIO;
+import org.lwjgl.BufferUtils;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL12.*;
+import static org.lwjgl.opengl.GL13.*;
+
+public class Texture
+{
+    private class Animation
+    {
+        private IntBuffer[] data;
+        private int[] wi;
+        private int[] he;
+        private final int offsetX;
+        private final int offsetY;
+        private int index = 0;
+        
+        private Animation(int offsetX, int offsetY, String... paths)
+        {
+            this.offsetX = offsetX;
+            this.offsetY = offsetY;
+            
+            int l = paths.length;
+            data = new IntBuffer[l];
+            wi = new int[l];
+            he = new int[l];
+            
+            for(int i = 0; i < l; i++)
+            {
+                BufferedImage image;
+                try
+                {
+                    image = ImageIO.read(new File(paths[i]));
+                }
+                catch(IOException | IllegalArgumentException ex)
+                {
+                    throw new TextureException("cannot read texture file '" + 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");
+                }
+                
+                wi[i] = image.getWidth();
+                he[i] = image.getHeight();
+                IntBuffer buffer = BufferUtils.createIntBuffer(wi[i] * he[i]);
+                for(int y = 0; y < he[i]; y++)
+                {
+                    for(int x = 0; x < wi[i]; x++)
+                    {
+                        int c = image.getRGB(x, he[i] - y - 1);
+                        buffer.put((c << 8) | ((c >> 24) & 0xFF));
+                    }
+                }
+                buffer.flip();
+                data[i] = buffer;
+            }
+        }
+        
+        private void nextFrame()
+        {
+            glBindTexture(GL_TEXTURE_2D, texture);
+            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 int texture = -1; 
+    private final String path;
+    private int w = -1;
+    private int h = -1;
+    
+    private final List<Animation> animations = new LinkedList<>();
+    
+    public Texture(String path)
+    {
+        this.path = path;
+        Shader.addTask(() -> loadTexture());
+    }
+    
+    public void addAnimation(int offsetX, int offsetY, String... paths)
+    {
+        Shader.addTask(() -> animations.add(new Animation(offsetX, offsetY, paths)));
+    }
+    
+    private void loadTexture()
+    {
+        if(texture != -1)
+        {
+            throw new TextureException("a texture is already loaded");
+        }
+        
+        BufferedImage image;
+        try
+        {
+            image = ImageIO.read(new File(path));
+        }
+        catch(IOException | IllegalArgumentException ex)
+        {
+            throw new TextureException("cannot read texture file '" + path + "'");
+        }
+        
+        w = image.getWidth();
+        h = image.getHeight();
+        IntBuffer buffer = BufferUtils.createIntBuffer(w * h);
+        for(int y = 0; y < h; y++)
+        {
+            for(int x = 0; x < w; x++)
+            {
+                int c = image.getRGB(x, h - y - 1);
+                buffer.put((c << 8) | ((c >> 24) & 0xFF));
+            }
+        }
+        buffer.flip();
+        
+        texture = glGenTextures();
+        
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buffer);
+    }    
+
+    public void bindTexture()
+    {
+        if(texture == -1)
+        {
+            throw new TextureException("cannot load non loaded texture");
+        }
+        
+        glActiveTexture(GL_TEXTURE0);
+        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);
+    }
+    
+    public void nextFrame()
+    {
+        animations.forEach(a -> a.nextFrame());
+    }
+}
+

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

@@ -0,0 +1,187 @@
+package me.hammerle.snuviengine.api;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.IntBuffer;
+import javax.imageio.ImageIO;
+import org.lwjgl.BufferUtils;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL12.*;
+import static org.lwjgl.opengl.GL13.*;
+
+public class TextureAtlas 
+{
+    private static final Texture NULL_TEXTURE = new Texture(0.0f, 0.0f, 0.0f, 0.0f);
+    
+    private static class Texture
+    {
+        private final float minX;
+        private final float minY;
+        private final float maxX;
+        private final float maxY;
+
+        private Texture(float minX, float minY, float maxX, float maxY)
+        {
+            this.minX = minX;
+            this.minY = minY;
+            this.maxX = maxX;
+            this.maxY = maxY;
+        }
+    }
+    
+    private final int tileWidth;
+    private final int tileHeight;
+    private final int width;    
+    private final int height;
+    
+    private Texture[] textures;
+    private int textureIndex = 0;
+    private final int[][] data;
+    
+    private int texture = -1; 
+    
+    private boolean generated = false;
+    
+    protected TextureAtlas(int tileWidth, int tileHeight, int width, int height)
+    {
+        this.tileWidth = tileWidth;
+        this.tileHeight = tileHeight;
+        this.width = width * tileWidth;
+        this.height = height * tileHeight;
+        
+        textures = new Texture[width * height];
+        for(int i = 0; i < textures.length; i++)
+        {
+            textures[i] = NULL_TEXTURE;
+        }
+        
+        data = new int[this.width][this.height];
+        
+        for(int x = 0; x < this.width; x++)
+        {
+            for(int y = 0; y < this.height; y++)
+            {
+               data[x][y] = 0xFF0000FF;
+            }
+        }
+    }
+    
+    protected void generateTexture()
+    {
+        if(generated)
+        {
+            throw new TextureException("the texture is already generated");
+        }
+        generated = true;
+        
+        texture = glGenTextures();
+        glBindTexture(GL_TEXTURE_2D, texture);
+
+        IntBuffer buffer = BufferUtils.createIntBuffer(width * height);       
+        for(int y = 0; y < height; y++)
+        {
+            for(int x = 0; x < width; x++)
+            {
+                buffer.put(data[x][y]);
+            }
+        }
+        buffer.flip();
+        
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, buffer);
+    }    
+
+    protected void bindTexture()
+    {
+        glActiveTexture(GL_TEXTURE0);
+        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);
+    }
+    
+    private int convertColor(int c)
+    {
+        return (c << 8) | ((c >> 24) & 0xFF);
+    }
+    
+    public int addTexture(String path)
+    {
+        if(generated)
+        {
+            throw new TextureException("cannot add a texture to an already generated texture atlas");
+        }
+        else if(textureIndex == textures.length)
+        {
+            throw new TextureException("the texture atlas is full");
+        }
+        
+        BufferedImage image;
+        try
+        {
+            image = ImageIO.read(new File(path));
+        }
+        catch(IOException | IllegalArgumentException ex)
+        {
+            throw new TextureException("cannot add texture '" + path + "'");
+        }
+        
+        if(image.getWidth() != tileWidth || image.getHeight() != tileHeight)
+        {
+            throw new TextureException("size of '" + path + "' is " + image.getWidth() + "x" + image.getHeight() + ", expected is " + tileWidth + "x" + tileHeight);
+        }
+
+        int x = (textureIndex % width) * tileWidth;
+        int y = (textureIndex / height) * tileHeight;           
+        textures[textureIndex] = new Texture(((float) x) / width, ((float) y) / height, ((float) (x + tileWidth)) / width, ((float) (y + tileHeight)) / height);
+        textureIndex++;
+
+        for(int ix = 0; ix < image.getWidth(); ix++)
+        {
+            for(int iy = 0; iy < image.getHeight(); iy++)
+            {
+                data[ix + x][iy + y] = convertColor(image.getRGB(ix, image.getHeight() - iy - 1));
+            }
+        }
+        return textureIndex - 1;
+    }
+    
+    protected float getTextureMinX(int index, boolean hFlip)
+    {
+        if(hFlip)
+        {
+            return textures[index].maxX;
+        }
+        return textures[index].minX;
+    }
+    
+    protected float getTextureMaxX(int index, boolean hFlip)
+    {
+        if(hFlip)
+        {
+            return textures[index].minX;
+        }
+        return textures[index].maxX;
+    }
+    
+    protected float getTextureMinY(int index, boolean vFlip)
+    {
+        if(vFlip)
+        {
+            return textures[index].maxY;
+        }
+        return textures[index].minY;
+    }
+    
+    protected float getTextureMaxY(int index, boolean vFlip)
+    {
+        if(vFlip)
+        {
+            return textures[index].minY;
+        }
+        return textures[index].maxY;
+    }
+}
+

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

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

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

@@ -0,0 +1,92 @@
+package me.hammerle.snuviengine.api;
+
+import java.nio.FloatBuffer;
+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 TextureRenderer
+{
+    private int vao;
+    private int vbo;
+    
+    private FloatBuffer buffer = BufferUtils.createFloatBuffer(12);
+    
+    private boolean built = false;
+    
+    public TextureRenderer()
+    {
+        Shader.addTask(() -> 
+        {
+            vao = glGenVertexArrays();
+            vbo = glGenBuffers();
+
+            glBindVertexArray(vao);
+            glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+            glEnableVertexAttribArray(0);
+            glVertexAttribPointer(0, 2, GL_FLOAT, false, 16, 0);
+
+            glEnableVertexAttribArray(1);  
+            glVertexAttribPointer(1, 2, GL_FLOAT, false, 16, 8);
+        });
+    }
+    
+    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() + 18 > buffer.capacity())
+        {
+            FloatBuffer newBuffer = BufferUtils.createFloatBuffer(buffer.capacity() * 2);
+            buffer.flip();
+            newBuffer.put(buffer);
+            buffer = newBuffer;
+        }
+        
+        buffer.put(x1);
+        buffer.put(y1);        
+        buffer.put(tx1);
+        buffer.put(ty1);
+        
+        buffer.put(x2);
+        buffer.put(y2);        
+        buffer.put(tx2);
+        buffer.put(ty2);
+        
+        buffer.put(x3);
+        buffer.put(y3);        
+        buffer.put(tx3);
+        buffer.put(ty3);
+    }
+    
+    public void addRectangle(float minX, float minY, float maxX, float maxY, float tMinX, float tMinY, float tMaxX, float tMaxY)
+    {
+        addTriangle(minX, maxY, minX, minY, maxX, maxY, tMinX, tMaxY, tMinX, tMinY, tMaxX, tMaxY);
+        addTriangle(maxX, maxY, minX, minY, maxX, minY, tMaxX, tMaxY, tMinX, tMinY, tMaxX, tMinY);
+    }
+    
+    public void build()
+    {
+        if(!Shader.initDone || buffer.position() == 0)
+        {
+            throw new ShaderException("build called too early");
+        }
+        buffer.flip();
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
+        built = true;
+    }
+    
+    public void draw()
+    {
+        if(!built)
+        {
+            throw new ShaderException("build must be called before drawing");
+        }
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glDrawArrays(GL_TRIANGLES, 0, buffer.limit() / 4);
+    }
+}

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

@@ -0,0 +1,107 @@
+package me.hammerle.snuviengine.game;
+
+import me.hammerle.snuviengine.api.ColorRenderer;
+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.Texture;
+import me.hammerle.snuviengine.api.TextureRenderer;
+import static org.lwjgl.glfw.GLFW.*;
+
+public class Game extends Engine
+{
+    private final static KeyBinding UP = KeyHandler.register(GLFW_KEY_W);
+    private final static KeyBinding DOWN = KeyHandler.register(GLFW_KEY_S);
+    private final static KeyBinding LEFT = KeyHandler.register(GLFW_KEY_A);
+    private final static KeyBinding RIGHT = KeyHandler.register(GLFW_KEY_D);
+    
+    private final ColorRenderer cr = new ColorRenderer();
+    private final TextureRenderer tr = new TextureRenderer();
+    private final Texture t = new Texture("images/out3.png");
+    
+    float x = 0.0f;
+    float y = 0.0f;
+    
+    int counter = 0;
+    
+    public Game()
+    {
+        t.addAnimation(0, 0, "water1.png", "water2.png", "water3.png", "water2.png");
+    }
+    
+    @Override
+    public void init()
+    {
+        /*Shader.getMap().getTextureAtlas().addTexture("images/out1.png");
+        Shader.getMap().getTextureAtlas().addTexture("images/out2.png");
+        Shader.getMap().getTextureAtlas().addTexture("images/out3.png");
+        Shader.getMap().getTextureAtlas().addTexture("images/out4.png");
+        Shader.getMap().getTextureAtlas().addTexture("images/out5.png");
+        
+        Shader.getMap().load("test");
+        
+        Shader.getMap().getAmbientLight().setColor(1.0f, 1.0f, 1.0f);*/
+        
+        /*Light l = Shader.getMap().getLight(0);
+        l.setColor(0.7f, 0.5f, 0.5f);
+        l.setStrength(0.005f);
+        l.setLocation(100.0f, 100.0f);*/
+        
+        //Shader.setLightUsing(true);
+        Shader.setAmbientLight(0.5f, 0.5f, 0.5f);
+        Shader.setLightLocation(0, 100, 100);
+        Shader.setLightColor(0, 0.5f, 0.4f, 0.4f);
+        Shader.setLightStrength(0, 0.01f);
+    }
+
+    @Override
+    public void tick()
+    {        
+        /*if(UP.isDown())
+        {
+            y += 5;
+        }
+        if(DOWN.isDown())
+        {
+            y -= 5;
+        }
+        if(LEFT.isDown())
+        {
+            x -= 5;
+        }
+        if(RIGHT.isDown())
+        {
+            x += 5;
+        }
+        Shader.getMap().setCamera(x, y);
+        Shader.getMap().getLight(0).setLocation(x + 16, y + 16);*/
+        counter++;
+        if(counter >= 20)
+        {
+            counter = 0;
+            t.nextFrame();
+        }
+    }
+    
+    @Override
+    public void renderTick()
+    {
+        //Shader.drawMap();
+        
+        Shader.setTextureUsing(false);
+        cr.setColor(1.0f, 1.0f, 0.f, 1.0f);
+        cr.addRectangle(20, 20, 300, 300);
+        cr.build();
+        cr.draw();
+        
+        Shader.setTextureUsing(true);
+        t.bindTexture();
+        for(int i = 0; i < 1000; i += 64)
+        {
+            tr.addRectangle(i, 64, i + 64, 128, 0.0f, 0.0f, 1.0f, 1.0f);
+        }
+        tr.build();
+        tr.draw();
+    }
+}