Graphical backbone is almost done, shaders need to be finished. Rewor…

…ked some structural things.

.classpath

@@ -2,5 +2,11 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="lib/jars/lwjgl.jar" sourcepath="lib/src.zip">
+		<attributes>
+			<attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="GameNoodle/lib/natives"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="lib" path="lib/jars/slick-util.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/entity/PlayerBall.java

@@ -0,0 +1,5 @@
+package entity;
+
+public class PlayerBall {
+
+}

src/game/Main.java

@@ -0,0 +1,118 @@
+package game;
+
+import static org.lwjgl.glfw.GLFW.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL13.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+import org.lwjgl.glfw.GLFWVidMode;
+import org.lwjgl.opengl.GL;
+
+import game.graphics.Shader;
+import game.input.Input;
+import game.level.Level;
+import game.math.Matrix4f;
+
+public class Main implements Runnable {
+
+	private int width = 1280;
+	private int height = 720;
+	private boolean running = false;
+	private Thread gameThread;
+	private long gameWindow;
+	private Level level;
+
+	//Must be explicitly declared to avoid being garbage collected
+	private Input input = new Input();
+
+	public void start() {
+		running = true;
+		gameThread = new Thread(this, "Game Noodle");
+		gameThread.start();
+	}
+
+	private void init() {
+		glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
+
+		// Windowed mode, don't share resources
+		gameWindow = glfwCreateWindow(width, height, "Game Noodle", NULL, NULL);
+
+		GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
+		glfwSetWindowPos(gameWindow, (vidmode.width() - width) / 2, (vidmode.height() - height) / 2);
+		glfwSetKeyCallback(gameWindow, input);
+		glfwMakeContextCurrent(gameWindow);
+		glfwShowWindow(gameWindow);
+		GL.createCapabilities();
+
+		glEnable(GL_DEPTH_TEST);
+		glActiveTexture(GL_TEXTURE1);
+		System.out.println("Loaded OpenGL Version: " + glGetString(GL_VERSION));
+		Shader.loadAll();
+
+		// Set all shader uniform variables here
+		Matrix4f projectionMatrix = Matrix4f.orthographic(-10.0f, 10.0f, -10.0f * 9.0f / 16.0f, 10.0f * 9.0f / 16.0f, -1.0f, 1.0f);
+
+		level = new Level();
+	}
+
+	public void run() {
+		init();
+
+		long prevTime = System.nanoTime();
+		double deltaT = 0.0;
+		double nanoSecConversion = 1000000000.0 / 60.0;
+		long timer = System.currentTimeMillis();
+		int currentUpdates = 0;
+		int currentFrames = 0;
+
+		while (running) {
+			// Frames/Updates per second counter and limiter
+			long currentTime = System.nanoTime();
+			deltaT += (currentTime - prevTime) / nanoSecConversion;
+			prevTime = currentTime;
+			if (deltaT >= 1.0) {
+				update();
+				currentUpdates++;
+				deltaT--;
+			}
+			render();
+			currentFrames++;
+			// If longer than one second has passed
+			if (System.currentTimeMillis() - timer > 1000) {
+				timer += 1000;
+				System.out.println("Updates Per Second: " + currentUpdates);
+				System.out.println("Frames Per Second: " + currentFrames);
+				currentUpdates = 0;
+				currentFrames = 0;
+			}
+
+			if (glfwWindowShouldClose(gameWindow) == GL_TRUE) {
+				running = false;
+			}
+		}
+
+		glfwDestroyWindow(gameWindow);
+		glfwTerminate();
+	}
+
+	public void update() {
+		glfwPollEvents();
+		level.update();
+	}
+
+	public void render() {
+		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+		level.render();
+
+		int error = glGetError();
+		if (error != GL_NO_ERROR) {
+			System.out.println("OpenGL Error: " + error);
+		}
+
+		glfwSwapBuffers(gameWindow);
+	}
+
+	public static void main(String[] args) {
+		new Main().start();
+	}
+}

src/game/graphics/Shader.java

@@ -0,0 +1,85 @@
+package game.graphics;
+
+import static org.lwjgl.opengl.GL20.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import game.math.Matrix4f;
+import game.math.Vector3f;
+import game.utils.ShaderUtils;
+
+
+public class Shader {
+
+	public static final int VERTEX_ATTRIB = 0;
+	public static final int TCOORD_ATTRIB = 1;
+
+//	public static Shader SHADERHERE;
+
+	private boolean enabled = false;
+
+	private final int ID;
+	private Map<String, Integer> locationCache = new HashMap<String, Integer>();
+
+	public Shader(String vertex, String fragment) {
+		ID = ShaderUtils.load(vertex, fragment);
+	}
+
+	public static void loadAll() {
+//		SHADERHERE = new Shader(vertPathStr, fragPathStr);
+	}
+
+	public int getUniform(String name) {
+		if (locationCache.containsKey(name)) {
+			return locationCache.get(name);
+		}
+		int result = glGetUniformLocation(ID, name);
+		if (result == -1) {
+			System.err.println("Could not find uniform variable '" + name + "'!");
+		} else {
+			locationCache.put(name, result);
+		}
+		return result;
+	}
+
+	public void setUniform1i(String name, int value) {
+		if (!enabled) {
+			enable();
+		}
+		glUniform1i(getUniform(name), value);
+	}
+
+	public void setUniform1f(String name, float value) {
+		if (!enabled) {
+			enable();
+		}
+		glUniform1f(getUniform(name), value);
+	}
+
+	public void setUniform2f(String name, float x, float y) {
+		if (!enabled) {
+			enable();
+		}
+		glUniform2f(getUniform(name), x, y);
+	}
+
+	public void setUniform3f(String name, Vector3f vector) {
+		if (!enabled) {
+			enable();
+		}
+		glUniform3f(getUniform(name), vector.x, vector.y, vector.z);
+	}
+
+	public void setUniformMat4f(String name, Matrix4f matrix) {
+		if (!enabled) {
+			enable();
+		}
+		glUniformMatrix4fv(getUniform(name), false, matrix.toFloatBuffer());
+	}
+
+	public void enable() {
+		glUseProgram(ID);
+		enabled = true;
+	}
+}

src/game/graphics/Texture.java

@@ -0,0 +1,61 @@
+package game.graphics;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import java.awt.image.BufferedImage;
+import java.io.FileInputStream;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import game.utils.BufferUtils;
+
+public class Texture {
+
+	private int width, height;
+	private int texture;
+
+	public Texture(String path) {
+		texture = load(path);
+	}
+
+	// Loads the image at the given path and binds the texture to the target
+	private int load(String path) {
+		int[] pixels = null; 
+		try {
+			BufferedImage image = ImageIO.read(new FileInputStream(path));
+			width = image.getWidth();
+			height = image.getHeight();
+			pixels = new int[width * height];
+			image.getRGB(0, 0, width, height, pixels, 0, width);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		int[] data = new int[width * height];
+
+		//Bit shifting in order to get the correct rgba values
+		for (int i = 0; i < width * height; i++) {
+			int a = (pixels[i] & 0xff000000) >> 24;
+			int r = (pixels[i] & 0xff0000) >> 16;
+			int g = (pixels[i] & 0xff00) >> 8;
+			int b = (pixels[i] & 0xff);
+
+			data[i] = a << 24 | b << 16 | g << 8 | r;
+		}
+
+		int result = glGenTextures();
+		glBindTexture(GL_TEXTURE_2D, result);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, BufferUtils.createIntBuffer(data));
+		glBindTexture(result, 0);
+		return result;
+	}
+
+	public void bind() {
+		glBindTexture(GL_TEXTURE_2D, texture);
+	}
+
+	public void unbind() {
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
+}