adds experimental support for usb controller

src/me/hammerle/snuviengine/Game.java

@@ -1,57 +1,30 @@
 package me.hammerle.snuviengine;
 
 import me.hammerle.snuviengine.api.Engine;
+import me.hammerle.snuviengine.api.GamepadBinding;
+import me.hammerle.snuviengine.api.GamepadHandler;
 import me.hammerle.snuviengine.api.IGame;
 import me.hammerle.snuviengine.api.Renderer;
 
 public class Game implements IGame
 {
-    private float oldX = 0;
-    private float oldY = 0;
-    private float x = 0;
-    private float y = 0;
-    
-    private float power = 10;
-    private final float size = 20;
-
     @Override
     public void tick()
     {        
-        oldX = x;
-        oldY = y;
-        
-        x += power;
-        y += power;
-        
-        if(y > 300 || y < 0)
-        {
-            power = -power;
-        }
     }
     
     @Override
     public void renderTick(Renderer r, float lag)
     { 
-        r.setMixColorEnabled(false);
-     
-        r.translateTo(0.0f, 0.0f);
-        r.updateMatrix();
-        
-        //lag = 0;
-        float ix = oldX + (x - oldX) * lag;
-        float iy = oldY + (y - oldY) * lag;
-        
-        r.setTextureEnabled(false);
-        r.getColorRenderer().drawRectangle(ix, iy, ix + size, iy + size, 0xFF0000FF);
-        
-        
-        float y = 200;
+        float y = 10;
         r.setColorEnabled(true);
         r.setTextureEnabled(true);
-        y = r.getFontRenderer().drawString(30, y, true, String.format("FPS: %.1f", Engine.getFramesPerSecond()));
-        y = r.getFontRenderer().drawString(30, y, true, String.format("Nanos Per Tick: %d", Engine.getNanosPerTick()));
-        y = r.getFontRenderer().drawString(30, y, true, String.format("TPS: %.1f", Engine.getTicksPerSecond()));
-        y = r.getFontRenderer().drawString(30, y, true, String.format("Lag: %.1f", lag));
+        y = r.getFontRenderer().drawString(10, y, true, String.format("FPS: %.1f", Engine.getFramesPerSecond()));
+        y = r.getFontRenderer().drawString(10, y, true, String.format("TPS: %.1f", Engine.getTicksPerSecond()));
+        for(GamepadBinding binding : GamepadHandler.BINDINGS)
+        {
+            y = r.getFontRenderer().drawString(10, y, true, String.format("%s: %b, %d, %b", binding.getName(), binding.isDown(), binding.getTime(), binding.isReleased()));
+        }
     }
 
     @Override

src/me/hammerle/snuviengine/Main.java

@@ -6,12 +6,8 @@ public class Main
 {
     public static void main(String[] args)
     {
-        Engine.init("wusi", 1024, 620);
-        
-        Engine.setNanosPerTick(50_000_000);
-        Engine.setMaxFramesPerSecond(60);
-        Engine.setRenderTicksPerSecond(true);
-        
+        Engine.init("wusi", 1024, 620);      
+        Engine.setNanosPerTick(50_000_000);          
         Game game = new Game();
         Engine.start(game);
     }

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

@@ -13,7 +13,6 @@ public class Engine
     
     private static long nanosPerTick = 10_000_000;
     private static final int MAX_TICKS_PER_FRAME = 20;
-    private static long nanosPerFrame = 1000000000l / 60l;
     
     private static Timer fpsTimer;
     private static Timer tpsTimer;
@@ -80,13 +79,13 @@ public class Engine
         });
         
         glfwMakeContextCurrent(window);
-        glfwSwapInterval(1);
+        glfwSwapInterval(2);
        
         GL.createCapabilities();
         
         renderer = new Renderer(width, height);
-        fpsTimer = new Timer(60);
-        tpsTimer = new Timer(1_000_000_000l / nanosPerTick);
+        fpsTimer = new Timer(60, 0.0f);
+        tpsTimer = new Timer(1_000_000_000l / nanosPerTick, height * 0.25f);
         
         glfwSetFramebufferSizeCallback(window, (w, fwidth, fheight) -> 
         {
@@ -97,95 +96,48 @@ public class Engine
         glfwShowWindow(window);
     }
     
-    private static void sleep(long nanos)
-    {
-        if(nanos < 0)
-        {
-            return;
-        }
-        
-        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 static void loop(IGame game)
     {
-        long newTime = System.nanoTime();
-        long oldTime;
+        long oldTime = System.nanoTime();
         long lag = 0;
-        long frameLag = 0;
-        long lastFrame = 0;
 
         while(!glfwWindowShouldClose(window))
         {
-            oldTime = newTime;
-            newTime = System.nanoTime();
+            long newTime = System.nanoTime();
             lag += newTime - oldTime;
-            frameLag += newTime - oldTime;
+            oldTime = newTime;
 
-            if(lag >= nanosPerTick || frameLag >= nanosPerFrame)
+            int ticksPerFrame = 0;
+            while(lag >= nanosPerTick)
             {
-                int ticksPerFrame = 0;
-                while(lag >= nanosPerTick)
-                {
-                    lag -= nanosPerTick;
+                lag -= nanosPerTick;
 
-                    tpsTimer.update();
-                    KeyHandler.tick();
-                    game.tick();
-                
-                    ticksPerFrame++;  
+                tpsTimer.update();
+                GamepadHandler.tick();
+                KeyHandler.tick();
+                game.tick();
 
-                    if(ticksPerFrame >= MAX_TICKS_PER_FRAME)
-                    {
-                        long skip = lag / nanosPerTick;
-                        lag -= skip * nanosPerTick;
-                        if(skip > 0)
-                        {
-                            System.out.println("skipped " + skip + " game ticks " + lag);
-                        }
-                        break;
-                    }
-                }
+                ticksPerFrame++;  
 
-                if(frameLag >= nanosPerFrame)
+                if(ticksPerFrame >= MAX_TICKS_PER_FRAME)
                 {
-                    frameLag -= nanosPerFrame;
-                    // make sure no frames are rendered immediately after each other
-                    // this happens if the game tick takes too long
-                    if(lastFrame + nanosPerFrame - 1000000 < System.nanoTime())
+                    long skip = lag / nanosPerTick;
+                    lag -= skip * nanosPerTick;
+                    if(skip > 0)
                     {
-                        lastFrame = System.nanoTime();
-
-                        game.renderTick(renderer, (float) lag / nanosPerTick);
-                        tpsTimer.draw(renderer);
-                        fpsTimer.draw(renderer);
-                        fpsTimer.update();   
-                        
-                        glfwSwapBuffers(window);
-                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+                        System.out.println(String.format("skipped %d game ticks %d", skip, lag));
                     }
+                    break;
                 }
-
-                glfwPollEvents();
-            }
-            else
-            {
-                // wait until next frame
-                long waitingTime = Math.min(nanosPerFrame - frameLag, nanosPerTick - lag);
-                sleep(waitingTime);
             }
+            
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            game.renderTick(renderer, (float) lag / nanosPerTick);
+            tpsTimer.draw(renderer);
+            fpsTimer.draw(renderer);
+            fpsTimer.update();   
+            glfwSwapBuffers(window);
+            glfwPollEvents();
         }
         game.onStop();
     }
@@ -215,12 +167,7 @@ public class Engine
     {
         return fpsTimer.getCallsPerSecond();
     }
-    
-    public static void setMaxFramesPerSecond(int max)
-    {
-        nanosPerFrame = 1_000_000_000 / max;
-    }
-    
+
     public static void setRenderFramesPerSecond(boolean active)
     {
         fpsTimer.setActive(active);

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

@@ -0,0 +1,66 @@
+package me.hammerle.snuviengine.api;
+
+public final class GamepadBinding
+{
+    private final String name;
+    private final int mapping;
+    
+    private boolean isDown = false;
+    private int time = 0;
+    private boolean isReleased = false;
+    
+    protected GamepadBinding(String name, int mapping)
+    {
+        this.name = name;
+        this.mapping = mapping;
+    }
+    
+    public String getName()
+    {
+        return name;
+    }
+
+    protected int getMapping()
+    {
+        return mapping;
+    }
+    
+    protected void tick(boolean isDown)
+    {
+        if(isReleased)
+        {
+            isReleased = false;
+            time = 0;
+        }
+        if(this.isDown && !isDown)
+        {
+            isReleased = true;
+            time++;
+        }
+        this.isDown = isDown;
+        if(isDown)
+        {
+            time++;
+        }
+    }
+    
+    public boolean isDown()
+    {
+        return isDown;
+    }
+
+    public boolean isReleased()
+    {
+        return isReleased;
+    }
+
+    public int getTime()
+    {
+        return time;
+    }
+
+    public void setTime(int time)
+    {
+        this.time = time;
+    }
+}

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

@@ -0,0 +1,69 @@
+package me.hammerle.snuviengine.api;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.util.function.Consumer;
+import static org.lwjgl.glfw.GLFW.*;
+
+public class GamepadHandler
+{
+    public final static GamepadBinding A = new GamepadBinding("A", 1);
+    public final static GamepadBinding B = new GamepadBinding("B", 2);
+    public final static GamepadBinding X = new GamepadBinding("X", 0);
+    public final static GamepadBinding Y = new GamepadBinding("Y", 3);
+    public final static GamepadBinding L = new GamepadBinding("L", 4);
+    public final static GamepadBinding R = new GamepadBinding("R", 5);
+    public final static GamepadBinding START = new GamepadBinding("Start", 9);
+    public final static GamepadBinding SELECT = new GamepadBinding("Select", 8);
+
+    public final static GamepadBinding LEFT = new GamepadBinding("Left", 0);
+    public final static GamepadBinding RIGHT = new GamepadBinding("Right", 0);
+    public final static GamepadBinding UP = new GamepadBinding("Up", 1);
+    public final static GamepadBinding DOWN = new GamepadBinding("Down", 1);
+
+    private final static GamepadBinding[] BUTTONS = new GamepadBinding[]
+    {
+        A, B, X, Y, L, R, START, SELECT
+    };
+    
+    public final static GamepadBinding[] BINDINGS = new GamepadBinding[]
+    {
+        A, B, X, Y, L, R, START, SELECT, LEFT, RIGHT, UP, DOWN
+    };
+
+    protected static void tick()
+    {
+        if(!glfwJoystickPresent(GLFW_JOYSTICK_1))
+        {
+            return;
+        }
+        updateButtons();
+        updateAxes();
+    }
+
+    private static void updateButtons()
+    {
+        ByteBuffer buttonBuffer = glfwGetJoystickButtons(GLFW_JOYSTICK_1);
+        if(buttonBuffer == null)
+        {
+            return;
+        }
+        for(GamepadBinding binding : BUTTONS)
+        {
+            binding.tick(buttonBuffer.get(binding.getMapping()) != 0);
+        }
+    }
+
+    private static void updateAxes()
+    {
+        FloatBuffer axesBuffer = glfwGetJoystickAxes(GLFW_JOYSTICK_1);
+        if(axesBuffer == null)
+        {
+            return;
+        }
+        LEFT.tick(axesBuffer.get(LEFT.getMapping()) < -0.5f);
+        RIGHT.tick(axesBuffer.get(RIGHT.getMapping()) > 0.5f);
+        UP.tick(axesBuffer.get(UP.getMapping()) < -0.5f);
+        DOWN.tick(axesBuffer.get(DOWN.getMapping()) > 0.5f);
+    }
+}

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

@@ -9,7 +9,6 @@ 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.GL30.*;
 
 public class Texture
 {

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

@@ -9,7 +9,7 @@ import static org.lwjgl.opengl.GL30.*;
 
 public class Timer
 {
-    private static final int SIZE = 128;
+    private static final int SIZE = 32;
     
     private int index = -1;
     private final long[] times = new long[SIZE];
@@ -25,10 +25,12 @@ public class Timer
     private boolean active = false;
     
     private float expectedValue;
+    private final float offset;
     
-    protected Timer(float expectedValue)
+    protected Timer(float expectedValue, float offset)
     {
         this.expectedValue = expectedValue;
+        this.offset = offset;
 
         vao = glGenVertexArrays();
         vbo = glGenBuffers();
@@ -73,6 +75,9 @@ public class Timer
             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);
+            
+            minY += offset;
+            maxY += offset;
 
             buffer.put(minX);
             buffer.put(maxY);