snuvi-engine/src/me/hammerle/snuviengine/api/Engine.java

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 class Engine
{
    private static long window;
    
    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;
    
    private static Renderer renderer;
    
    private Engine()
    {
    }    

    public static void start(IGame game)
    {
        loop(game);

        glfwFreeCallbacks(window);
        glfwDestroyWindow(window);

        glfwTerminate();
        GLFWErrorCallback error = glfwSetErrorCallback(null);
        if(error != null)
        {
            error.free();
        }
    }
    
    public static void stop()
    {
        glfwSetWindowShouldClose(window, true);
    }

    public static void init(String name, int width, int height)
    {
        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);
        
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

        window = glfwCreateWindow(width, height, name, NULL, NULL);
        if(window == NULL)
        {
            throw new IllegalStateException("Failed to create the GLFW window");
        }

        glfwSetKeyCallback(window, (w, key, scancode, action, mods) -> 
        {
            if(action == GLFW_RELEASE)
            {
                KeyHandler.onKeyUpEvent(key);
            }
            else if(action == GLFW_PRESS)
            {
                KeyHandler.onKeyDownEvent(key);
            }
        });
        
        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);
            renderer.setViewPort(fwidth, fheight);
        });
        
        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 = glfwGetTimerValue();
        long oldTime;
        long lag = 0;
        long frameLag = 0;
        long lastFrame = 0;

        while(!glfwWindowShouldClose(window))
        {
            oldTime = newTime;
            newTime = glfwGetTimerValue();
            lag += newTime - oldTime;
            frameLag += newTime - oldTime;

            if(lag >= nanosPerTick || frameLag >= nanosPerFrame)
            {
                int ticksPerFrame = 0;
                while(lag >= nanosPerTick)
                {
                    lag -= nanosPerTick;

                    tpsTimer.update();
                    KeyHandler.tick();
                    game.tick();
                
                    ticksPerFrame++;  

                    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;
                    }
                }

                if(frameLag >= nanosPerFrame)
                {
                    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 < glfwGetTimerValue())
                    {
                        lastFrame = glfwGetTimerValue();

                        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);
                    }
                }

                glfwPollEvents();
            }
            else
            {
                // wait until next frame
                long waitingTime = Math.min(nanosPerFrame - frameLag, nanosPerTick - lag);
                sleep(waitingTime);
            }
        }
        game.onStop();
    }
    
    public static void setNanosPerTick(long nanos)
    {
        nanosPerTick = nanos;
        tpsTimer.setExpectedValue(1_000_000_000l / nanos);
    }
    
    public static long getNanosPerTick()
    {
        return nanosPerTick;
    }
    
    public static double getTicksPerSecond()
    {
        return tpsTimer.getCallsPerSecond();
    }
    
    public static void setRenderTicksPerSecond(boolean active)
    {
        tpsTimer.setActive(active);
    }
    
    public static double getFramesPerSecond()
    {
        return fpsTimer.getCallsPerSecond();
    }
    
    public static void setMaxFramesPerSecond(int max)
    {
        nanosPerFrame = 1_000_000_000 / max;
    }
    
    public static void setRenderFramesPerSecond(boolean active)
    {
        fpsTimer.setActive(active);
    }
}