fps limiter, timer class for tps and fps, timer status rendering, face collision (left, right, up down)

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

@@ -34,8 +34,6 @@ public class ColorRenderer
             glEnableVertexAttribArray(0);
             glEnableVertexAttribArray(2);
             
-            // 128 k - 130k
-            
             glVertexAttribPointer(0, 3, GL_FLOAT, false, 16, 0);
             glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, true, 16, 12);
         });
@@ -56,35 +54,35 @@ public class ColorRenderer
             offset = 0;
             glBufferData(GL_ARRAY_BUFFER, BUFFER_BYTE_LENGTH, GL_STREAM_DRAW);
         }
-        ByteBuffer tbuffer = glMapBufferRange(GL_ARRAY_BUFFER, offset, OBJECT_LENGTH, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT, buffer);
-        if(tbuffer == null)
+        buffer = glMapBufferRange(GL_ARRAY_BUFFER, offset, OBJECT_LENGTH, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT, buffer);
+        if(buffer == null)
         {
             return;
         }
         
         float fcolor = Float.intBitsToFloat(color);
         
-        tbuffer.putFloat(minX);
-        tbuffer.putFloat(maxY);   
-        tbuffer.putFloat(depth);  
-        tbuffer.putFloat(fcolor);
+        buffer.putFloat(minX);
+        buffer.putFloat(maxY);   
+        buffer.putFloat(depth);  
+        buffer.putFloat(fcolor);
         
-        tbuffer.putFloat(minX);
-        tbuffer.putFloat(minY);   
-        tbuffer.putFloat(depth);  
-        tbuffer.putFloat(fcolor);
+        buffer.putFloat(minX);
+        buffer.putFloat(minY);   
+        buffer.putFloat(depth);  
+        buffer.putFloat(fcolor);
         
-        tbuffer.putFloat(maxX);
-        tbuffer.putFloat(maxY);  
-        tbuffer.putFloat(depth);  
-        tbuffer.putFloat(fcolor);
+        buffer.putFloat(maxX);
+        buffer.putFloat(maxY);  
+        buffer.putFloat(depth);  
+        buffer.putFloat(fcolor);
         
-        tbuffer.putFloat(maxX);
-        tbuffer.putFloat(minY);  
-        tbuffer.putFloat(depth);  
-        tbuffer.putFloat(fcolor);
+        buffer.putFloat(maxX);
+        buffer.putFloat(minY);  
+        buffer.putFloat(depth);  
+        buffer.putFloat(fcolor);
         
-        tbuffer.flip();
+        buffer.flip();
 
         glUnmapBuffer(GL_ARRAY_BUFFER);
         

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

@@ -15,19 +15,14 @@ public abstract class Engine
     
     private long window;
     
-    private int fpsIndex = 0;
-    private final long[] fps = new long[200];
-    private long fpsSum = 0;
-    private double currentFps = 0;
-    
-    private int tpsIndex = 0;
-    private final long[] tps = new long[200];
-    private long tpsSum = 0;
-    private double currentTps = 0;
-    
+    private long fpsLimit = -1;
+    private long sleep = 0;
     private long nanosPerTick = 10_000_000;
     private final int maxTicksPerFrame = 20;
     
+    private final Timer fps = new Timer(60);
+    private final Timer tps = new Timer(1_000_000_000l / nanosPerTick);
+    
     public Engine()
     {
     }    
@@ -96,46 +91,66 @@ public abstract class Engine
        
         glfwShowWindow(window);
     }
+    
+    private void sleep(long nanos)
+    {
+        if(nanos < 0)
+        {
+            sleep += nanos;
+            return;
+        }
+        
+        if(sleep < 0)
+        {
+            sleep += nanos / 4;
+            nanos = (nanos * 3) / 4;
+        }
+        
+        long end = System.nanoTime() + nanos - 10000;
+        try
+        {
+            Thread.sleep(nanos / 1_000_000);
+        }
+        catch(InterruptedException ex)
+        {
+        }
+        int i = 0;
+        while(System.nanoTime() < end)
+        {
+            i++;
+        }
+    }
 
     private void loop()
     {
         GL.createCapabilities();
         
-        long lastFrame = System.nanoTime();
-        long lastTick = System.nanoTime();
-        long time;
-        long lag = 0;
-        
         Shader.init();
         init();
         
+        fps.update();
+        tps.update();
+        long lag = 0;
+        
         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];
-            lag += fps[fpsIndex];
-            fpsIndex = (fpsIndex + 1) % fps.length;
-            lastFrame = time;
-            currentFps = (1_000_000_000.0 * fps.length) / fpsSum;
+            if(fpsLimit > 0)
+            {
+                sleep(fpsLimit - fps.getCurrentTime());
+            }
+            fps.update();
+            lag += fps.getTime();
 
             int ticksPerFrame = 0;
             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;
+                tps.update();
                 
                 KeyHandler.tick();
                 tick();
@@ -154,7 +169,11 @@ public abstract class Engine
             }
             
             Shader.doTasks();
-            renderTick();
+            
+            renderTick((float) lag / nanosPerTick);
+            
+            tps.draw();
+            fps.draw();
 
             glfwPollEvents();
         }
@@ -163,21 +182,42 @@ public abstract class Engine
     public final void setNanosPerTick(long nanos)
     {
         nanosPerTick = nanos;
+        tps.setExpectedValue(1_000_000_000l / nanos);
+    }
+    
+    public final long getNanosPerTick()
+    {
+        return nanosPerTick;
     }
     
     public final double getTps()
     {
-        return currentTps;
+        return tps.getCallsPerSecond();
+    }
+    
+    public final void setRenderTps(boolean active)
+    {
+        tps.setActive(active);
     }
     
     public final double getFps()
     {
-        return currentFps;
+        return fps.getCallsPerSecond();
+    }
+    
+    public final void setMaxFps(int max)
+    {
+        fpsLimit = 1_000_000_000 / max;
+    }
+    
+    public final void setRenderFps(boolean active)
+    {
+        fps.setActive(active);
     }
     
     public abstract void init();
     public abstract void tick();
-    public abstract void renderTick();
+    public abstract void renderTick(float lag);
 }
 
 

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

@@ -0,0 +1,147 @@
+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 Timer
+{
+    private static final int SIZE = 128;
+    
+    private int index = -1;
+    private final long[] times = new long[SIZE];
+    private long sum = 0;
+    private double callsPerSecond = 0;
+    private long lastTime = System.nanoTime();
+    
+    private int vao;
+    private int vbo;
+    
+    private final FloatBuffer buffer = BufferUtils.createFloatBuffer(18);
+    
+    private boolean active = false;
+    
+    private float expectedValue;
+    
+    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);
+        });
+    }
+    
+    protected void setActive(boolean active)
+    {
+        this.active = active;
+    }
+    
+    protected void update()
+    {
+        index = (index + 1) & (SIZE - 1);
+        
+        long time = System.nanoTime();
+        sum -= times[index];
+        times[index] = time - lastTime;
+        sum += times[index];
+        lastTime = time;
+        callsPerSecond = (1_000_000_000.0 * SIZE) / sum;
+        
+        if(active)
+        {
+            float minX = index * 3;
+            float minY = 0.0f;
+            float maxX = minX + 2;
+            float maxY = 1_000_000_000.0f / times[index];
+
+            float diff = (maxY - expectedValue) / expectedValue;
+            int r = Math.min((int) (128 * (1 - Math.min(diff, 0.0f) * 16)), 255);
+            int g = Math.min((int) (128 * (1 + Math.max(diff, 0.0f) * 16)), 255);
+            int b = (int) (128 * (1 - Math.abs(diff)));
+            float color = Float.intBitsToFloat(r | (g << 8) | (b << 16) | 0xFF000000);
+
+            buffer.put(minX);
+            buffer.put(maxY);   
+            buffer.put(color);
+
+            buffer.put(minX);
+            buffer.put(minY);   
+            buffer.put(color);
+
+            buffer.put(maxX);
+            buffer.put(maxY);  
+            buffer.put(color);
+
+            buffer.put(minX);
+            buffer.put(minY);   
+            buffer.put(color);
+
+            buffer.put(maxX);
+            buffer.put(maxY);  
+            buffer.put(color);
+
+            buffer.put(maxX);
+            buffer.put(minY);  
+            buffer.put(color);
+
+            buffer.flip();
+
+            GLHelper.glBindBuffer(vbo);
+            glBufferSubData(GL_ARRAY_BUFFER, index * buffer.limit() * 4, buffer);
+        }
+    }
+    
+    protected void setExpectedValue(float value)
+    {
+        expectedValue = value;
+    }
+    
+    protected long getAverageTime()
+    {
+        return sum / SIZE;
+    }
+    
+    protected long getCurrentTime()
+    {
+        return System.nanoTime() - lastTime;
+    }
+    
+    protected long getTime()
+    {
+        return times[index];
+    }
+    
+    protected double getCallsPerSecond()
+    {
+        return callsPerSecond;
+    }
+    
+    protected void draw()
+    {
+        if(active)
+        {
+            Shader.setTextureEnabled(false);
+            Shader.setColorEnabled(true);
+
+            GLHelper.glBindBuffer(vbo);
+            GLHelper.glBindVertexArray(vao);
+            glDrawArrays(GL_TRIANGLES, 0, SIZE * 6);
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ import java.util.function.Consumer;
 
 public class BoxList
 {
-    private static final double MAX_SIZE = 1;
+    private static final double MAX_SIZE = 2.5;
     
     private final Entity[] entities = new Entity[70000];
     private int lastFreeEntity = entities.length - 1;

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

@@ -3,11 +3,16 @@ 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
 {
+    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;
@@ -28,8 +33,8 @@ public class Entity
         this.width = width;
         this.height = height;
         
-        vx = Math.random() * 4 - 2;
-        vy = Math.random() * 4 - 2;
+        vx = Math.random() * 8 + 5;
+        vy = Math.random() * 8 + 5;
     }
     
     private boolean isColliding(Entity ent)
@@ -46,41 +51,46 @@ public class Entity
     
     public void tick()
     {
-        counter++;
-        if(counter == 200)
+        if(!(this instanceof Hero))
         {
-            counter = 0;
-            vx = Math.random() * 4 - 2;
-            vy = Math.random() * 4 - 2;
+            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 step = 0.0625;
         double lvx = vx;
         double lvy = vy;
               
         List<Entity> list = game.entities.getAllEntitiesAt(this, 
-                xPos + ((vx < 0) ? vx : 0), 
-                yPos + ((vy < 0) ? vy : 0), 
-                xPos + width + ((vx > 0) ? vx : 0), 
-                yPos + height + ((vy > 0) ? vy : 0));
+                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;
-            if(xPos < 0 || xPos > 400)
-            {
-                xPos -= vx;
-            }
-            
-            yPos += vy;
-            if(yPos < 0 || yPos > 300)
-            {
-                yPos -= vy;
-            }
+            xPos = Math.max(Math.min(vx + xPos, 400), 0);
+            yPos = Math.max(Math.min(vy + yPos, 300), 0);
             
             game.entities.update(this);
             return;
@@ -93,28 +103,28 @@ public class Entity
             
             if(lvx < 0.0)
             {
-                if(lvx > -step)
+                if(lvx > -STEP)
                 {
                     xPos += lvx;
                     lvx = 0.0;
                 }
                 else
                 {
-                    xPos -= step;
-                    lvx += step;
+                    xPos -= STEP;
+                    lvx += STEP;
                 }
             }
             else if(lvx > 0.0)
             {
-                if(lvx < step)
+                if(lvx < STEP)
                 {
                     xPos += lvx;
                     lvx = 0.0;
                 }
                 else
                 {
-                    xPos += step;
-                    lvx -= step;
+                    xPos += STEP;
+                    lvx -= STEP;
                 }
             }
             
@@ -138,28 +148,28 @@ public class Entity
             
             if(lvy < 0.0)
             {
-                if(lvy > -step)
+                if(lvy > -STEP)
                 {
                     yPos += lvy;
                     lvy = 0.0;
                 }
                 else
                 {
-                    yPos -= step;
-                    lvy += step;
+                    yPos -= STEP;
+                    lvy += STEP;
                 }
             }
             else if(lvy > 0.0)
             {
-                if(lvy < step)
+                if(lvy < STEP)
                 {
                     yPos += lvy;
                     lvy = 0.0;
                 }
                 else
                 {
-                    yPos += step;
-                    lvy -= step;
+                    yPos += STEP;
+                    lvy -= STEP;
                 }
             }
             
@@ -183,17 +193,43 @@ public class Entity
         }
         
         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 renderTick()
+    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);
-        Shader.getColorRenderer().drawRectangle(
-                (float) xPos, 
-                (float) yPos, 
-                (float) (xPos + width), 
-                (float) (yPos + height), 
-                0x770000FF);
+        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()
@@ -211,10 +247,4 @@ public class Entity
         xPos = x;
         yPos = y;
     }
-
-    @Override
-    public String toString()
-    {
-        return Integer.toHexString(hashCode());
-    }
 }

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

@@ -1,7 +1,5 @@
 package me.hammerle.snuviengine.game;
 
-import java.util.LinkedList;
-import java.util.List;
 import java.util.Random;
 import me.hammerle.snuviengine.api.Engine;
 import me.hammerle.snuviengine.api.KeyBinding;
@@ -19,6 +17,11 @@ public class Game extends Engine
     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();
     private final Texture t = new Texture("images/out3.png");
     
@@ -26,24 +29,24 @@ public class Game extends Engine
     
     public Game()
     {
-        Random r = new Random(100);
-        for(int i = 0; i < 4096; i++)
+        Random r = new Random(200);
+        for(int i = 0; i < 128; i++)
         {
-            Entity ent = new Entity(this, 2.0, 2.0);
+            Entity ent = new Entity(this, 5.0, 5.0);
             ent.setPosition((int) (r.nextDouble() * 400.0), (int) (r.nextDouble() * 300));
             ent.node = entities.add(ent);
         }
         
-        /*Hero hero = new Hero(this, 1.0, 1.0);
+        Hero hero = new Hero(this, 5.0, 5.0);
         hero.setPosition(300.0, 200);
         hero.node = entities.add(hero);
-        list.add(hero);*/
     }
     
     @Override
     public void init()
     {
-        setNanosPerTick(10_000_000);
+        setNanosPerTick(50_000_000);
+        setMaxFps(120);
     }
 
     @Override
@@ -53,16 +56,28 @@ public class Game extends Engine
         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()
+    public void renderTick(float lag)
     {
         Shader.setTextureEnabled(false);
         Shader.setColorEnabled(true);
-        entities.forEach(ent -> ent.renderTick());
+        Shader.getColorRenderer().drawRectangle(0, 299, 400, 300, 0xFFFFFFFF);
+        entities.forEach(ent -> ent.renderTick(lag));
         
         Shader.setTextureEnabled(true);
         Shader.setColorEnabled(true);

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

@@ -1,6 +1,7 @@
 package me.hammerle.snuviengine.game;
 
 import me.hammerle.snuviengine.api.Shader;
+import me.hammerle.snuviengine.util.Face;
 
 public class Hero extends Entity
 {
@@ -10,15 +11,12 @@ public class Hero extends Entity
     }
     
     @Override
-    public void renderTick()
+    public void renderTick(float lag)
     {
         Shader.getColorRenderer().setDepth((float) yPos);
-        Shader.getColorRenderer().drawRectangle(
-                (float) (xPos), 
-                (float) (yPos), 
-                (float) (xPos + width), 
-                (float) (yPos + height),
-                0xAAFF0000);
+        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
@@ -26,7 +24,7 @@ public class Hero extends Entity
     {
         double nvx = 0.0;
         double nvy = 0.0;
-        double speed = 3;
+        double speed = 5;
         
         if(Game.DOWN.isDown())
         {
@@ -53,4 +51,10 @@ public class Hero extends Entity
         
         super.tick();
     }
+
+    @Override
+    public void onCollide(Face f, Entity ent)
+    {
+        
+    }
 }

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

@@ -0,0 +1,28 @@
+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;
+    }
+}