First update

Diffuse light/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/LWJGL3"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Diffuse light/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Diffuse light</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Diffuse light/bin/.gitignore

@@ -0,0 +1 @@
+/fr/

Diffuse light/res/shaders/light.frag

@@ -0,0 +1,78 @@
+#version 150
+//precision highp float;
+uniform mat4 transform;
+uniform sampler2D materialTex;
+uniform float materialShininess;
+uniform vec3 materialSpecularColor;
+uniform vec3 cameraPosition;
+
+#define MAX_LIGHTS 10
+uniform int numLights;
+uniform struct Light {
+   vec4 position;
+   vec3 intensities; //a.k.a the color of the light
+   float attenuation;
+   float ambientCoefficient;
+   float coneAngle;
+   vec3 coneDirection;
+} allLights[MAX_LIGHTS];
+
+in vec2 fragTexCoord;
+in vec3 fragNormal;
+in vec3 fragVert;
+
+out vec4 finalColor;
+
+vec3 ApplyLight(Light light, vec3 surfaceColor, vec3 normal, vec3 surfacePos, vec3 surfaceToCamera) {
+    vec3 surfaceToLight;
+    float attenuation = 1.0;
+    if(light.position.w == 0.0) {
+        //directional light
+        surfaceToLight = normalize(light.position.xyz);
+        attenuation = 1.0; //no attenuation for directional lights
+    } else {
+        //point light
+        surfaceToLight = normalize(light.position.xyz - surfacePos);
+        float distanceToLight = length(light.position.xyz - surfacePos);
+        attenuation = 1.0 / (1.0 + light.attenuation * pow(distanceToLight, 2));
+
+        //cone restrictions (affects attenuation)
+        float lightToSurfaceAngle = degrees(acos(dot(-surfaceToLight, normalize(light.coneDirection))));
+        if(lightToSurfaceAngle > light.coneAngle){
+            attenuation = 0.0;
+        }
+    }
+
+    //ambient
+    vec3 ambient = light.ambientCoefficient * surfaceColor.rgb * light.intensities;
+
+    //diffuse
+    float diffuseCoefficient = max(0.0, dot(normal, surfaceToLight));
+    vec3 diffuse = diffuseCoefficient * surfaceColor.rgb * light.intensities;
+    
+    //specular
+    float specularCoefficient = 0.0;
+    if(diffuseCoefficient > 0.0)
+        specularCoefficient = pow(max(0.0, dot(surfaceToCamera, reflect(-surfaceToLight, normal))), materialShininess);
+    vec3 specular = specularCoefficient * materialSpecularColor * light.intensities;
+
+    //linear color (color before gamma correction)
+    return ambient + attenuation*(diffuse + specular);
+}
+
+void main() {
+    vec3 normal = normalize(transpose(inverse(mat3(transform))) * fragNormal);
+    vec3 surfacePos = vec3(transform * vec4(fragVert, 1));
+    vec4 surfaceColor = texture(materialTex, fragTexCoord);
+    vec3 surfaceToCamera = normalize(cameraPosition - surfacePos);
+    
+    //combine color from all the lights
+    vec3 linearColor = vec3(0);
+    for(int i = 0; i < numLights; ++i){
+        linearColor += ApplyLight(allLights[i], surfaceColor.rgb, normal, surfacePos, surfaceToCamera);
+    }
+    
+    //final color (after gamma correction)
+    vec3 gamma = vec3(1.0/2.2);
+    finalColor = vec4(pow(linearColor, gamma), surfaceColor.a);
+}

Diffuse light/res/shaders/light.vert

@@ -0,0 +1,23 @@
+#version 150
+
+uniform mat4 projection;
+uniform mat4 camera;
+uniform mat4 transform;
+
+in vec3 vert;
+in vec2 vertTexCoord;
+in vec3 vertNormal;
+
+out vec3 fragVert;
+out vec2 fragTexCoord;
+out vec3 fragNormal;
+
+void main() {
+    // Pass some variables to the fragment shader
+    fragTexCoord = vertTexCoord;
+    fragNormal = vertNormal;
+    fragVert = vert;
+    
+    // Apply all matrix transformations to vert
+    gl_Position = projection * camera * transform * vec4(vert, 1);
+}

Diffuse light/src/fr/technicalgames/Main.java

@@ -0,0 +1,103 @@
+package fr.technicalgames;
+import static org.lwjgl.glfw.GLFW.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+import org.lwjgl.glfw.*;
+import org.lwjgl.opengl.*;
+
+import fr.technicalgames.game.*;
+import fr.technicalgames.input.*;
+import fr.technicalgames.math.*;
+import fr.technicalgames.render.*;
+
+public class Main {
+	
+	//Valeur de la fenetre
+	public static final int WIDTH = 800,HEIGHT = 600;
+	public static final String TITLE = "Test Shader OpenGL";
+	
+	//Variable pour la gestion de la fenetre
+	public static long windowID = 0;
+	public static float mousePositionX = 0,mousePositionY = 0,dMouseX = 0,dMouseY = 0;
+	public static GLFWErrorCallback errorCallback;
+	
+	//variable du moteur du jeu
+	public static float delta = 0;
+	public static Game game;
+	public static long previous = System.currentTimeMillis(),previousInfo = System.currentTimeMillis(),previousTicks = System.currentTimeMillis();
+	public static int FPS = 0,TICKS = 0;
+	
+	public static void main(String[] args) throws Exception {
+		//Creation de la fenetre
+		//------------------------------------------------------------------------------------
+		errorCallback = new GLFWErrorCallback() {
+			public void invoke(int error, long description) {
+				System.err.println("ID : " + error + " | Description :" + description);				
+			}
+		};
+//		glfwSetErrorCallback(errorCallback);
+		
+		if(glfwInit() != GL11.GL_TRUE)throw new Exception("GLFW not init");
+		glfwDefaultWindowHints();
+		glfwWindowHint(GLFW_VISIBLE, GL11.GL_FALSE);	
+		glfwWindowHint(GLFW_RESIZABLE, GL11.GL_FALSE);
+		glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+	    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+	    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+		windowID = glfwCreateWindow(WIDTH,HEIGHT,TITLE,NULL,NULL);
+		GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
+		glfwSetWindowPos(windowID,(vidmode.width()-WIDTH)/2,(vidmode.height()-HEIGHT)/2);
+		glfwShowWindow(windowID);
+		glfwMakeContextCurrent(windowID);
+		GL.createCapabilities();
+	    System.out.println("OpenGL Version :" + glGetString(GL_VERSION));
+	    System.out.println("GLSL Shader Version :" + glGetString(GL20.GL_SHADING_LANGUAGE_VERSION));
+	    //------------------------------------------------------------------------------------
+		
+	    //initialisation
+	    //------------------------------------------------------------------------------------
+	    Input.init();
+	    game = new MainGame();
+	    
+	    Camera.rot = new Vector3f(-3.0f,-338.0f,0.0f);
+	    Camera.pos = new Vector3f(1.5242399f,0.0f,-13.456063f);
+	    Camera.transform();
+	    //------------------------------------------------------------------------------------
+		
+		while(glfwWindowShouldClose(windowID) == GL11.GL_FALSE){
+		    
+		    if(System.currentTimeMillis() - previousTicks >= 1000/60){//Update TICKS
+			    glfwPollEvents();
+			    Input.update();
+			    game.update();
+		    	previousTicks = System.currentTimeMillis();
+			    delta = (float)(System.currentTimeMillis() - previous)/1000.0f;
+			    previous = System.currentTimeMillis();
+		    	TICKS++;
+		    }else{//Update FPS
+		    	DisplayManager.clear();
+		    	DisplayManager.preRender3D();
+		    	DisplayManager.render3D();
+		    	DisplayManager.preRender2D();
+		    	DisplayManager.render2D();
+		    	DisplayManager.preRenderGUI();
+		    	DisplayManager.renderGUI();
+				glfwSwapBuffers(windowID);
+				FPS++;
+		    }
+		    
+		    if(System.currentTimeMillis() - previousInfo >= 1000){
+		    	glfwSetWindowTitle(windowID, TITLE + " | FPS:" + FPS + " TICKS:" + TICKS);
+		    	FPS = 0;
+		    	TICKS = 0;
+		    	previousInfo = System.currentTimeMillis();
+		    }
+		}
+		
+		glfwDestroyWindow(windowID);
+		glfwTerminate();
+	}
+	
+}

Diffuse light/src/fr/technicalgames/game/Game.java

@@ -0,0 +1,26 @@
+package fr.technicalgames.game;
+
+import java.util.*;
+
+import fr.technicalgames.light.*;
+import fr.technicalgames.render.*;
+
+public abstract class Game {
+
+	public static ArrayList<Asset> assets = new ArrayList<Asset>();
+	public static ArrayList<Light> lights = new ArrayList<Light>();
+	
+	public Game(){
+		init();
+		System.out.println(this.getClass().getSimpleName() + " loaded with " + assets.size() + " assets and with " + lights.size() + " lights !");
+	}
+	
+	public abstract void init();
+	public abstract void update();
+	public abstract void render2D();
+	public abstract void render3D();
+	public abstract void renderGUI();
+	public abstract void destroy();
+	
+	
+}

Diffuse light/src/fr/technicalgames/game/MainGame.java

@@ -0,0 +1,71 @@
+package fr.technicalgames.game;
+
+import fr.technicalgames.*;
+import fr.technicalgames.light.*;
+import fr.technicalgames.math.*;
+import fr.technicalgames.render.*;
+
+public class MainGame extends Game{
+	
+    private float value = 0;
+
+	@Override
+	public void init() {
+		
+	    lights.add(new SpotLight(new Vector3f(-4,0,10),new Vector3f(2,2,2),0.1f,0.0f,15.0f,new Vector3f(0,0,-1)));
+	    lights.add(new DirectionalLight(new Vector3f(4,0,-10), new Vector3f(0.4f,0.3f,0.1f), 0.06f));
+	    
+	    
+	    Asset as = new Asset();
+	    as.transform = (new Matrix4f());
+	    assets.add(as);
+	    as = new Asset();
+	    as.transform = (new Matrix4f()).tranlate(0, -4, 0).scale(1, 2, 1);
+	    assets.add(as);
+	    as = new Asset();
+	    as.transform = (new Matrix4f()).tranlate(-8,0,0).scale(1, 6, 1);
+	    assets.add(as);
+	    as = new Asset();
+	    as.transform = (new Matrix4f()).tranlate(-4,0,0).scale(1, 6, 1);
+	    assets.add(as);
+	    as = new Asset();
+	    as.transform = (new Matrix4f()).tranlate(-6,0,0).scale(2,1,0.8f);
+	    assets.add(as);
+	    as = null;
+	}
+
+	@Override
+	public void update() {
+	    Camera.update();
+	    Camera.transform();
+		
+	    lights.get(0).position.y = Mathf.cos(value) * 6f;
+	    lights.get(0).position.x = Mathf.sin(value) * 3f - 4f;
+	    value += Main.delta * 1.0f;
+	}
+
+	@Override
+	public void render2D() {
+		
+	}
+
+	@Override
+	public void render3D() {
+	    for(Asset a : assets){
+	    	a.render(lights);
+	    }
+	}
+
+	@Override
+	public void renderGUI() {
+		
+	}
+
+	@Override
+	public void destroy() {
+		for(Asset a : assets){
+	    	a.destroy();
+	    }
+	}
+
+}

Diffuse light/src/fr/technicalgames/input/IO.java

@@ -0,0 +1,17 @@
+package fr.technicalgames.input;
+import java.io.*;
+
+public class IO {
+
+	public static String loadFile(String path) throws Exception{
+		String r = "";
+		BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
+		String buffer = "";
+		while ((buffer = reader.readLine()) != null) {
+				r += buffer + "\n";
+		}
+		reader.close();
+		return r;
+	}
+	
+}

Diffuse light/src/fr/technicalgames/input/Input.java

@@ -0,0 +1,245 @@
+package fr.technicalgames.input;
+
+
+import static org.lwjgl.glfw.GLFW.*;
+
+import java.util.*;
+import java.util.Map.*;
+
+import org.lwjgl.glfw.*;
+
+import fr.technicalgames.*;
+import fr.technicalgames.math.*;
+
+public class Input{
+	
+	public static GLFWScrollCallback scroll;
+	public static GLFWCursorPosCallback mousePos;
+	
+	private static Vector2f mousePosition = new Vector2f();
+	private static Vector2f dMouse = new Vector2f();
+	private static Vector2f previousDMouse = new Vector2f();
+	
+	public static final int NONE = 0,PRESSED = 1,RELEASED = 2,REPEATED = 3,UP = 4,DOWN = 5,
+			NBRE_KEY = 0x15D,NBRE_BUTTON = 10,
+			MOUSE_OFFSET = NBRE_KEY + 1,MOUSE_WHEEL_OFFSET = MOUSE_OFFSET + 1;
+	
+	private static HashMap<Integer,Integer> state = new HashMap<Integer,Integer>();
+	
+	private static double ywheel = 0;
+	
+	public static void init(){
+		glfwSetScrollCallback(Main.windowID, scroll = new GLFWScrollCallback() {
+			public void invoke(long window, double xoffset, double yoffset) {
+				scroll(window, xoffset, yoffset);
+			}
+		});
+		glfwSetCursorPosCallback(Main.windowID, mousePos = new GLFWCursorPosCallback() {
+			public void invoke(long window, double xpos, double ypos) {
+				mousepos(window, xpos, ypos);
+			}
+		});
+		for(int i = 0;i < NBRE_KEY;i++){
+			state.put(i, NONE);
+		}
+		for(int i = 0;i < NBRE_BUTTON;i++){
+			state.put(i + MOUSE_OFFSET, NONE);
+		}
+		state.put(MOUSE_WHEEL_OFFSET, NONE);
+	}
+	
+	public static void update(){
+		for(Entry<Integer, Integer> set : state.entrySet()){
+			int i = set.getKey();
+			int st = set.getValue();
+			if(i > -1 && i < NBRE_KEY){
+				if(glfwGetKey(Main.windowID, i) == 0 && st == NONE)continue;
+				if(glfwGetKey(Main.windowID, i) == 1 && st == NONE){
+					state.replace(i, PRESSED);
+				}else if(glfwGetKey(Main.windowID, i) == 1 && st == PRESSED){
+					state.replace(i, REPEATED);
+				}else if(glfwGetKey(Main.windowID, i) == 0 && (st == PRESSED || st == REPEATED)){
+					state.replace(i, RELEASED);
+				}else if(glfwGetKey(Main.windowID, i) == 0 && st == RELEASED){
+					state.replace(i, NONE);
+				}
+			}else if(i >= MOUSE_OFFSET && i < MOUSE_OFFSET + NBRE_BUTTON){
+				if(glfwGetMouseButton(Main.windowID, i - MOUSE_OFFSET) == 0 && st == NONE)continue;
+				if(glfwGetMouseButton(Main.windowID, i - MOUSE_OFFSET) == 1 && st == NONE){
+					state.replace(i, PRESSED);
+				}else if(glfwGetMouseButton(Main.windowID, i - MOUSE_OFFSET) == 1 && st == PRESSED){
+					state.replace(i, REPEATED);
+				}else if(glfwGetMouseButton(Main.windowID, i - MOUSE_OFFSET) == 0 && (st == PRESSED || st == REPEATED)){
+					state.replace(i, RELEASED);
+				}else if(glfwGetMouseButton(Main.windowID, i - MOUSE_OFFSET) == 0 && st == RELEASED){
+					state.replace(i, NONE);
+				}
+			}
+		}
+		int st = state.get(MOUSE_WHEEL_OFFSET);
+		if(ywheel > 0 && (st == NONE || st == UP)){
+			state.replace(MOUSE_WHEEL_OFFSET, UP);
+		}else if(ywheel < 0 && (st == NONE || st == DOWN)){
+			state.replace(MOUSE_WHEEL_OFFSET, DOWN);
+		}else if(ywheel == 0 && (st == DOWN || st == UP)){
+			state.replace(MOUSE_WHEEL_OFFSET, NONE);
+		}
+		ywheel = 0;
+		if(dMouse.equals(previousDMouse)){
+			dMouse = new Vector2f();
+		}else{
+			previousDMouse = dMouse;
+		}
+	}
+	
+	public static void destroy(){
+		mousePos.release();
+		scroll.release();
+	}
+	
+	public static void scroll(long window, double xoffset, double yoffset) {
+		ywheel = yoffset;
+	}
+	
+	public static void mousepos(long window, double xpos, double ypos) {
+		dMouse.x = (float) (xpos - mousePosition.x);
+		dMouse.y = (float) (ypos - mousePosition.y);
+		mousePosition.x = (float) xpos;
+		mousePosition.y = (float) ypos;
+	}
+	
+	public static boolean isButtonDown(int button){
+		return state.get(button + MOUSE_OFFSET) == PRESSED;
+	}
+	
+	public static boolean isButtonUp(int button){
+		return state.get(button + MOUSE_OFFSET) == RELEASED;
+	}
+	
+	public static boolean isButton(int button){
+		return state.get(button + MOUSE_OFFSET) == PRESSED || state.get(button + MOUSE_OFFSET) == REPEATED;
+	}
+	
+	public static int isButtonState(int button){
+		return state.get(button + MOUSE_OFFSET);
+	}
+	
+	public static boolean isKeyDown(int key){
+		return state.get(key) == PRESSED;
+	}
+	
+	public static boolean isKeyUp(int key){
+		return state.get(key) == RELEASED;
+	}
+	
+	public static boolean isKey(int key){
+		return state.get(key) == PRESSED || state.get(key) == REPEATED;
+	}
+	
+	public static int isKeyState(int key){
+		return state.get(key);
+	}
+	
+	public static int isMouseWheelState(){
+		return state.get(MOUSE_WHEEL_OFFSET);
+	}
+	
+	public static boolean isMouseWheelUp(){
+		return state.get(MOUSE_WHEEL_OFFSET) == UP;
+	}
+	
+	public static boolean isMouseWheelDown(){
+		return state.get(MOUSE_WHEEL_OFFSET) == DOWN;
+	}
+
+	public static GLFWScrollCallback getScroll() {
+		return scroll;
+	}
+
+	public static void setScroll(GLFWScrollCallback scroll) {
+		Input.scroll = scroll;
+	}
+
+	public static GLFWCursorPosCallback getMousePos() {
+		return mousePos;
+	}
+
+	public static void setMousePos(GLFWCursorPosCallback mousePos) {
+		Input.mousePos = mousePos;
+	}
+
+	public static Vector2f getMousePosition() {
+		return mousePosition;
+	}
+
+	public static void setMousePosition(Vector2f mousePosition) {
+		Input.mousePosition = mousePosition;
+	}
+
+	public static Vector2f getDMouse() {
+		return dMouse;
+	}
+
+	public static void setDMouse(Vector2f dMouse) {
+		Input.dMouse = dMouse;
+	}
+
+	public static HashMap<Integer, Integer> getState() {
+		return state;
+	}
+
+	public static void setState(HashMap<Integer, Integer> state) {
+		Input.state = state;
+	}
+
+	public static double getYwheel() {
+		return ywheel;
+	}
+
+	public static void setYwheel(double ywheel) {
+		Input.ywheel = ywheel;
+	}
+
+	public static int getNone() {
+		return NONE;
+	}
+
+	public static int getPressed() {
+		return PRESSED;
+	}
+
+	public static int getReleased() {
+		return RELEASED;
+	}
+
+	public static int getRepeated() {
+		return REPEATED;
+	}
+
+	public static int getUp() {
+		return UP;
+	}
+
+	public static int getDown() {
+		return DOWN;
+	}
+
+	public static int getNbreKey() {
+		return NBRE_KEY;
+	}
+
+	public static int getNbreButton() {
+		return NBRE_BUTTON;
+	}
+
+	public static int getMouseOffset() {
+		return MOUSE_OFFSET;
+	}
+
+	public static int getMouseWheelOffset() {
+		return MOUSE_WHEEL_OFFSET;
+	}
+	
+	
+	
+}

Diffuse light/src/fr/technicalgames/light/DirectionalLight.java

@@ -0,0 +1,18 @@
+package fr.technicalgames.light;
+
+import fr.technicalgames.math.*;
+
+public class DirectionalLight extends Light{
+
+	public DirectionalLight(Vector3f position, Vector3f intensities,float ambientCoefficient) {
+		super(new Vector4f(position,0), intensities, 1.0f, ambientCoefficient, 0.0f, new Vector3f());
+	}
+
+	@Override
+	public void update() {
+		
+	}
+	
+	
+
+}

Diffuse light/src/fr/technicalgames/light/Light.java

@@ -0,0 +1,74 @@
+package fr.technicalgames.light;
+import fr.technicalgames.math.*;
+
+public abstract class Light {
+
+	public Vector4f position;//w == 0 si c une directional light
+	public Vector3f intensities;
+	public float attenuation;
+    public float ambientCoefficient;
+    public float coneAngle;
+    public Vector3f  coneDirection;
+    
+    public Light(Vector4f position,Vector3f intensities,float attenuation,float ambientCoefficient,float coneAngle,Vector3f coneDirection){
+    	this.position = position;
+    	this.intensities = intensities;
+    	this.attenuation = attenuation;
+    	this.ambientCoefficient = ambientCoefficient;
+    	this.coneAngle = coneAngle;
+    	this.coneDirection = coneDirection;
+    }
+    
+    public abstract void update();
+
+	public Vector4f getPosition() {
+		return position;
+	}
+
+	public void setPosition(Vector4f position) {
+		this.position = position;
+	}
+
+	public Vector3f getIntensities() {
+		return intensities;
+	}
+
+	public void setIntensities(Vector3f intensities) {
+		this.intensities = intensities;
+	}
+
+	public float getAttenuation() {
+		return attenuation;
+	}
+
+	public void setAttenuation(float attenuation) {
+		this.attenuation = attenuation;
+	}
+
+	public float getAmbientCoefficient() {
+		return ambientCoefficient;
+	}
+
+	public void setAmbientCoefficient(float ambientCoefficient) {
+		this.ambientCoefficient = ambientCoefficient;
+	}
+
+	public float getConeAngle() {
+		return coneAngle;
+	}
+
+	public void setConeAngle(float coneAngle) {
+		this.coneAngle = coneAngle;
+	}
+
+	public Vector3f getConeDirection() {
+		return coneDirection;
+	}
+
+	public void setConeDirection(Vector3f coneDirection) {
+		this.coneDirection = coneDirection;
+	}
+    
+    
+	
+}

Diffuse light/src/fr/technicalgames/light/SpotLight.java

@@ -0,0 +1,17 @@
+package fr.technicalgames.light;
+
+import fr.technicalgames.math.*;
+
+public class SpotLight extends Light{
+
+	public SpotLight(Vector3f position, Vector3f intensities, float attenuation, float ambientCoefficient,
+			float coneAngle, Vector3f coneDirection) {
+		super(new Vector4f(position,1), intensities, attenuation, ambientCoefficient, coneAngle, coneDirection);
+	}
+
+	@Override
+	public void update() {
+		
+	}
+
+}

Diffuse light/src/fr/technicalgames/material/DefaultMaterial.java

@@ -0,0 +1,11 @@
+package fr.technicalgames.material;
+
+import fr.technicalgames.math.*;
+
+public class DefaultMaterial extends Material{
+
+	public DefaultMaterial() {
+		super(80.0f, new Vector3f(1,1,1));
+	}
+
+}

Diffuse light/src/fr/technicalgames/material/Material.java

@@ -0,0 +1,31 @@
+package fr.technicalgames.material;
+
+import fr.technicalgames.math.*;
+
+public abstract class Material {
+
+	public float shininess;
+	public Vector3f specularColor;
+	
+	public Material(float shininess,Vector3f specularColor){
+		this.shininess = shininess;
+		this.specularColor = specularColor;
+	}
+
+	public float getShininess() {
+		return shininess;
+	}
+
+	public void setShininess(float shininess) {
+		this.shininess = shininess;
+	}
+
+	public Vector3f getSpecularColor() {
+		return specularColor;
+	}
+
+	public void setSpecularColor(Vector3f specularColor) {
+		this.specularColor = specularColor;
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Color4f.java

@@ -0,0 +1,110 @@
+package fr.technicalgames.math;
+
+
+import static org.lwjgl.opengl.GL11.*;
+
+public class Color4f {
+	
+	public static final Color4f 
+			RED = new Color4f(1,0,0,1),
+			BLUE = new Color4f(0,0,1,1),
+			GREEN = new Color4f(0,1,0,1),
+			YELLOW = new Color4f(1,1,0,1),
+			PURPLE = new Color4f(1,0,1,1),
+			CYAN = new Color4f(0,1,1,1),
+			BLACK = new Color4f(0,0,0,1),
+			WHITE = new Color4f(1,1,1,1);
+	
+	public float r,g,b,a;
+		
+	public Color4f(float r,float g,float b,float a){
+		this.r = r;
+		this.g = g;
+		this.b = b;
+		this.a = a;
+	}
+
+	public static Color4f mul (Color4f a, float b){
+	   return new Color4f(a.r * b,a.g * b,a.b * b,a.a * b);
+	}
+	
+	public static Color4f mul (float o,Color4f... a){
+		float r = 0;
+		float b = 0;
+		float g = 0;
+		float al = 0;
+		for(Color4f c : a){
+			r += c.r;
+			g += c.g;
+			b += c.b;
+			al += c.a;
+		}
+		r /= a.length;
+		g /= a.length;
+		b /= a.length;
+		al /= a.length;
+	   return new Color4f(r * o,g * o,b * o,al * o);
+	}
+	
+	public static Color4f mul (Color4f... a){
+		float r = 0;
+		float b = 0;
+		float g = 0;
+		float al = 0;
+		for(Color4f c : a){
+			r += c.r;
+			g += c.g;
+			b += c.b;
+			al += c.a;
+		}
+		r /= a.length;
+		g /= a.length;
+		b /= a.length;
+		al /= a.length;
+	   return new Color4f(r,g,b,al);
+	}
+	
+	public Color4f() {
+	}
+
+	public float getR() {
+		return r;
+	}
+
+	public void setR(float r) {
+		this.r = r;
+	}
+
+	public float getG() {
+		return g;
+	}
+
+	public void setG(float g) {
+		this.g = g;
+	}
+
+	public float getB() {
+		return b;
+	}
+
+	public void setB(float b) {
+		this.b = b;
+	}
+
+	public float getA() {
+		return a;
+	}
+
+	public void setA(float a) {
+		this.a = a;
+	}
+	
+	public void bind(){
+		glColor4f(r,g,b,a);
+	}
+	
+	public void unbind(){
+		BLACK.bind();
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Mathf.java

@@ -0,0 +1,67 @@
+package fr.technicalgames.math;
+
+
+public class Mathf {
+
+	public static final float PI = 3.14159265358979323846f;
+	public static final float EPSILON = 1.401298e-45f;
+	
+	public static float cos(float angle){
+		return (float)Math.cos(angle);
+	}
+	
+	public static float acos(float angle){
+		return (float)Math.acos(angle);
+	}
+	
+	public static float sin(float angle){
+		return (float)Math.sin(angle);
+	}
+	
+	public static float asin(float angle){
+		return (float)Math.asin(angle);
+	}
+
+	public static float toRadians(float angle){
+		return (float)Math.toRadians(angle);
+	}
+	
+	public static float toDegrees(float angle){
+		return (float)Math.toDegrees(angle);
+	}
+	
+	public static float atan2(float a,float b){
+		return (float)Math.atan2(a,b);
+	}
+	
+	public static float cut(float nbre,float a){
+		return (float)((int)(nbre*Math.pow(10, a))/Math.pow(10, a));
+	}
+
+	public static boolean equals(float a,float b,float tolerance){
+		return (a + tolerance >= b) && (a - tolerance <= b);
+	}
+	
+	public static float sqrt(float a){
+		return (float)Math.sqrt(a);
+	}
+	
+	public static float exp(float a){
+		return (float)Math.sqrt(a);
+	}
+	
+	public static float log(float a){
+		return (float)Math.log(a);
+	}
+	
+	public static float clamp(float value, float min, float max) {
+		if(value < min){
+			value = min;
+		}
+		if(value > max){
+			value = max;
+		}
+		return value;
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Matrix4f.java

@@ -0,0 +1,189 @@
+package fr.technicalgames.math;
+
+
+import java.nio.*;
+import java.util.*;
+
+import org.lwjgl.*;
+
+public class Matrix4f {
+
+	public float[][] m = null;
+	
+	public Matrix4f(){
+		m = new float[][]{
+			{1,0,0,0},
+			{0,1,0,0},
+			{0,0,1,0},
+			{0,0,0,1}
+		};
+	}
+	
+	public Matrix4f(float[][] m){
+		this.m = m;
+	}
+	
+	public Matrix4f loadIdentity(){
+		m = new float[][]{
+			{1,0,0,0},
+			{0,1,0,0},
+			{0,0,1,0},
+			{0,0,0,1}
+		};
+		return this;
+	}
+	
+	public Matrix4f rotate(Quaternion q){
+		Matrix4f rot = q.toMatrixRotation();
+		m = mul(rot).getM();
+		return this;
+	}
+
+	
+	public void rotate(float x,float y,float z){
+		x = Mathf.toRadians(x);
+		y = Mathf.toRadians(y);
+		z = Mathf.toRadians(z);
+		Matrix4f rx = new Matrix4f(new float[][]{
+			{1,0,0,0},
+			{0,Mathf.cos(x),-Mathf.sin(x),0},
+			{0,Mathf.sin(x),Mathf.cos(x),0},
+			{0,0,0,1}
+		});
+		
+		Matrix4f ry = new Matrix4f(new float[][]{
+			{Mathf.cos(y),0,Mathf.sin(y),0},
+			{0,1,0,0},
+			{-Mathf.sin(y),0,Mathf.cos(y),0},
+			{0,0,0,1}
+		});
+		
+		Matrix4f rz = new Matrix4f(new float[][]{
+			{Mathf.cos(z),-Mathf.sin(z),0,0},
+			{Mathf.sin(z),Mathf.cos(z),0,0},
+			{0,0,1,0},
+			{0,0,0,1}
+		});
+		Matrix4f m1 = (rz.mul(ry.mul(rx)));
+		m = mul(m1).getM();
+	}
+	
+	public static Matrix4f rotate(Vector3f forward, Vector3f up, Vector3f right)
+	{
+		Matrix4f mat = new Matrix4f(new float[][]{
+			{right.getX(),	right.getY(),	right.getZ()	,0},
+			{up.getX(),		up.getY(),		up.getZ()		,0},
+			{forward.getX(),forward.getY(),	forward.getZ()	,0},
+			{0,0,0,1}
+		});
+		return mat;
+	}
+	
+	public Matrix4f tranlate(float x,float y,float z){
+		Matrix4f mat = new Matrix4f(new float[][]{
+			{1,0,0,x},
+			{0,1,0,y},
+			{0,0,1,z},
+			{0,0,0,1}
+		});
+		m = mul(mat).getM();
+		return this;
+	}
+	
+	public Matrix4f scale(float x,float y,float z){
+		Matrix4f mat = new Matrix4f(new float[][]{
+			{x,0,0,0},
+			{0,y,0,0},
+			{0,0,z,0},
+			{0,0,0,1}
+		});
+		m = mul(mat).getM();
+		return this;
+	}
+
+	public Matrix4f mul(Matrix4f mat){
+		Matrix4f ma = new Matrix4f();
+		for(int i = 0;i < 4;i++){
+			for(int j = 0;j < 4;j++){
+				ma.m[i][j] = m[i][0] * mat.m[0][j] + 
+						m[i][1] * mat.m[1][j] + 
+						m[i][2] * mat.m[2][j] + 
+						m[i][3] * mat.m[3][j];
+			}
+		}
+		return ma;
+	}
+	
+	public Matrix4f Ortho2D(float left, float right, float bottom, float top, float near, float far)
+	{
+		float width = right - left;
+		float height = top - bottom;
+		float depth = far - near;
+		
+		m = new float[][]{
+			{2/width,0,0,-(right + left)/width},
+			{0,2/height,0,-(top + bottom)/height},
+			{0,0,-2/depth,-(far + near)/depth},
+			{0,0,0,1}
+		};
+
+		return this;
+	}
+	
+	public Matrix4f perspective(float fov, float aspectRatio, float zNear, float zFar)
+	{
+		float f = fov;
+		fov = Mathf.toRadians(f);
+		float tanHalfFOV = (float)Math.tan(fov / 2);
+		float zRange = zNear - zFar;
+		
+		m = new float[][]{
+			{1.0f / (tanHalfFOV * aspectRatio),0,0,0},
+			{0,1.0f / tanHalfFOV,0,0},
+			{0,0,(-zNear -zFar)/zRange,2.0f * zFar * zNear / zRange},
+			{0,0,1,0}
+		};
+		
+		return this;
+	}
+	
+	public FloatBuffer getBuffer(){
+		FloatBuffer buffer = BufferUtils.createFloatBuffer(4 * 4);
+		for(int i = 0;i < 4;i++){
+			buffer.put(m[i]);
+		}
+		buffer.flip();
+		return buffer;		
+	}
+
+	public String toString(){
+		int size = 3;
+		int max = 10;
+		StringJoiner st = new StringJoiner("\n","--------Mat4-Begin--------\n","\n--------Mat4-End----------");
+		for(int i = 0;i < 4;i++){
+			StringJoiner st2 = new StringJoiner(" | ");
+			for(int j = 0;j < 4;j++){
+				String value = Mathf.cut(m[i][j], size) + "";
+				for(int k = value.length();k < max;k++){
+					value += " ";
+				}
+				st2.add(value);
+			}
+			st.add(st2.toString());
+		}
+		return st.toString();
+	}
+	
+	public float[][] getM() {
+		return m;
+	}
+
+	public void setM(float[][] m) {
+		this.m = m;
+	}
+	
+	public Matrix4f copy(){
+		return new Matrix4f(this.getM());
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Quaternion.java

@@ -0,0 +1,132 @@
+package fr.technicalgames.math;
+
+
+public class Quaternion {
+
+	public float x,y,z,w;
+	
+	public Quaternion(){
+		x = 0;
+		y = 0;
+		z = 0;
+		w = 0;
+	}
+	
+	public Quaternion(Vector3f axis,float angle){
+		float sin = Mathf.sin(Mathf.toRadians(angle/2.0f));
+		float cos = Mathf.cos(Mathf.toRadians(angle/2.0f));
+		x = axis.getX() * sin;
+		y = axis.getY() * sin;
+		z = axis.getZ() * sin;
+		w = cos;
+	}
+	
+	public Quaternion(Vector3f rot){
+		this(rot.x,rot.y,rot.z);
+	}
+	
+	public Quaternion (float yaw, float roll, float pitch) {
+		yaw = Mathf.toRadians(yaw);
+		roll = Mathf.toRadians(roll);
+		pitch = Mathf.toRadians(pitch);
+        float angle;
+        float sinRoll, sinPitch, sinYaw, cosRoll, cosPitch, cosYaw;
+        angle = pitch * 0.5f;
+        sinPitch = Mathf.sin(angle);
+        cosPitch = Mathf.cos(angle);
+        angle = roll * 0.5f;
+        sinRoll = Mathf.sin(angle);
+        cosRoll = Mathf.cos(angle);
+        angle = yaw * 0.5f;
+        sinYaw = Mathf.sin(angle);
+        cosYaw = Mathf.cos(angle);
+
+        // variables used to reduce multiplication calls.
+        float cosRollXcosPitch = cosRoll * cosPitch;
+        float sinRollXsinPitch = sinRoll * sinPitch;
+        float cosRollXsinPitch = cosRoll * sinPitch;
+        float sinRollXcosPitch = sinRoll * cosPitch;
+        
+        w = (cosRollXcosPitch * cosYaw - sinRollXsinPitch * sinYaw);
+        x = (cosRollXcosPitch * sinYaw + sinRollXsinPitch * cosYaw);
+        y = (sinRollXcosPitch * cosYaw + cosRollXsinPitch * sinYaw);
+        z = (cosRollXsinPitch * cosYaw - sinRollXcosPitch * sinYaw);
+        
+        normalize();
+    }
+	
+	public void normalize(){
+		float n = (float)(1.0/Math.sqrt(norm()));
+        x *= n;
+        y *= n;
+        z *= n;
+        w *= n;
+	}
+	
+	public float norm(){
+		return w * w + x * x + y * y + z * z;
+	}
+	
+	public Quaternion Euler(Vector3f rot) {
+	    x = Mathf.toRadians(rot.x);
+	    y = Mathf.toRadians(rot.y);
+	    z = Mathf.toRadians(rot.z);
+		float c1 = Mathf.cos(y/2);
+		float s1 = Mathf.sin(y/2);
+		float c2 = Mathf.cos(z/2);
+		float s2 = Mathf.sin(z/2);
+		float c3 = Mathf.cos(x/2);
+		float s3 = Mathf.sin(x/2);
+	    float c1c2 = c1*c2;
+	    float s1s2 = s1*s2;
+	    this.w =c1c2*c3 - s1s2*s3;
+	  	this.x =c1c2*s3 + s1s2*c3;
+		this.y =s1*c2*c3 + c1*s2*s3;
+		this.z =c1*s2*c3 - s1*c2*s3;
+		return new Quaternion(x, y, z, w);
+	}
+	
+	public Vector3f toEulerAngles(){
+		Vector3f euler = new Vector3f();
+
+	    float sqw = w * w;
+	    float sqx = x * x;
+	    float sqy = y * y;
+	    float sqz = z * z;
+	    float unit = sqx + sqy + sqz + sqw; // if normalized is one, otherwise
+	                                                                            // is correction factor
+	    float test = x * y + z * w;
+	    if (test > 0.499 * unit) { // singularity at north pole
+	            euler.y = 2 * Mathf.atan2(x, w);
+	            euler.z = Mathf.PI/2.0f;
+	            euler.x = 0;
+	    } else if (test < -0.499 * unit) { // singularity at south pole
+	    		euler.y = -2 * Mathf.atan2(x, w);
+	    		euler.z = -Mathf.PI/2.0f;
+	    		euler.x = 0;
+	    } else {
+	    		euler.y = Mathf.atan2(2 * y * w - 2 * x * z, sqx - sqy - sqz + sqw); // roll or heading 
+	    		euler.z = Mathf.asin(2 * test / unit); // pitch or attitude
+	    		euler.x = Mathf.atan2(2 * x * w - 2 * y * z, -sqx + sqy - sqz + sqw); // yaw or bank
+	    }
+        return euler.toDegrees();
+	}
+	
+	public Quaternion(float axisX,float axisY,float axisZ,float angle){
+		float sin = Mathf.sin(Mathf.toRadians(angle/2.0f));
+		float cos = Mathf.cos(Mathf.toRadians(angle/2.0f));
+		x = axisX * sin;
+		y = axisY * sin;
+		z = axisZ * sin;
+		w = cos;
+	}
+	
+	public Matrix4f toMatrixRotation(){
+		Vector3f forward =  new Vector3f(2.0f * (x * z - w * y), 2.0f * (y * z + w * x), 1.0f - 2.0f * (x * x + y * y));
+		Vector3f up = new Vector3f(2.0f * (x * y + w * z), 1.0f - 2.0f * (x * x + z * z), 2.0f * (y * z - w * x));
+		Vector3f right = new Vector3f(1.0f - 2.0f * (y * y + z * z), 2.0f * (x * y - w * z), 2.0f * (x * z + w * y));
+
+		return Matrix4f.rotate(forward, up, right);
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Vector2f.java

@@ -0,0 +1,42 @@
+package fr.technicalgames.math;
+
+
+import java.util.*;
+
+public class Vector2f {
+
+	public float x,y;
+	
+	public Vector2f(){
+		x = 0;
+		y = 0;
+	}
+	
+	public Vector2f(float x,float y){
+		this.x = x;
+		this.y = y;
+	}
+
+	public float getX() {
+		return x;
+	}
+
+	public void setX(float x) {
+		this.x = x;
+	}
+
+	public float getY() {
+		return y;
+	}
+
+	public void setY(float y) {
+		this.y = y;
+	}
+	
+	public String toString(){
+		StringJoiner st = new StringJoiner(",","vec2(",")");
+		st.add("" + x);
+		st.add("" + y);
+		return st.toString();
+	}
+}

Diffuse light/src/fr/technicalgames/math/Vector3f.java

@@ -0,0 +1,104 @@
+package fr.technicalgames.math;
+
+
+import java.util.*;
+
+public class Vector3f {
+
+	public float x,y,z;
+	
+	public Vector3f(){
+		x = 0;
+		y = 0;
+		z = 0;
+	}
+	
+	public Vector3f(float x,float y,float z){
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+	
+	public Vector3f(Vector2f vec,float z){
+		this(vec.x,vec.y,z);
+	}
+	
+	public Vector3f(Vector3f vec){
+		this(vec.x,vec.y,vec.z);
+	}
+
+	public float getX() {
+		return x;
+	}
+
+	public void setX(float x) {
+		this.x = x;
+	}
+
+	public float getY() {
+		return y;
+	}
+
+	public void setY(float y) {
+		this.y = y;
+	}
+
+	public float getZ() {
+		return z;
+	}
+
+	public void setZ(float z) {
+		this.z = z;
+	}
+	
+	public float length(){
+		return Mathf.sqrt(x * x + y * y + z * z);
+	}
+	
+	public Vector3f lookAt(Vector3f d){
+		Vector3f rot = new Vector3f();
+		float x1 = d.x - x;
+		float y1 = d.y - y;
+		float z1 = d.z - z;
+		
+		return rot;
+	}
+	
+	public Vector3f normalize(){
+		float length = length();
+		x /= length;
+		y /= length;
+		z /= length;
+		return this;
+	}
+	
+	public Vector3f mul(float m){
+		x *= m;
+		y *= m;
+		z *= m;
+		return this;
+	}
+	
+	public String toString(){
+		StringJoiner st = new StringJoiner(",","vec3(",")");
+		st.add("" + x);
+		st.add("" + y);
+		st.add("" + z);
+		return st.toString();
+	}
+
+	public Vector3f toRadians() {
+		x = Mathf.toRadians(x);
+		y = Mathf.toRadians(y);
+		z = Mathf.toRadians(z);
+		return this;
+	}
+	
+	public Vector3f toDegrees() {
+		x = Mathf.toDegrees(x);
+		y = Mathf.toDegrees(y);
+		z = Mathf.toDegrees(z);
+		return this;
+	}
+	
+}

Diffuse light/src/fr/technicalgames/math/Vector4f.java

@@ -0,0 +1,56 @@
+package fr.technicalgames.math;
+
+public class Vector4f {
+
+	public float x,y,z,w;
+	
+	public Vector4f(float x,float y,float z,float w){
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.w = w;
+	}
+	
+	public Vector4f(Vector3f v,float w){
+		this.x = v.x;
+		this.y = v.y;
+		this.z = v.z;
+		this.w = w;
+	}
+
+	public float getX() {
+		return x;
+	}
+
+	public void setX(float x) {
+		this.x = x;
+	}
+
+	public float getY() {
+		return y;
+	}
+
+	public void setY(float y) {
+		this.y = y;
+	}
+
+	public float getZ() {
+		return z;
+	}
+
+	public void setZ(float z) {
+		this.z = z;
+	}
+
+	public float getW() {
+		return w;
+	}
+
+	public void setW(float w) {
+		this.w = w;
+	}
+	
+	
+	
+	
+}

Diffuse light/src/fr/technicalgames/render/Asset.java

@@ -0,0 +1,133 @@
+package fr.technicalgames.render;
+import java.nio.*;
+import java.util.*;
+
+import org.lwjgl.*;
+import org.lwjgl.opengl.*;
+
+import fr.technicalgames.light.*;
+import fr.technicalgames.material.*;
+import fr.technicalgames.math.*;
+
+public class Asset {
+
+	public int vbo,vao;
+	public Texture texture;
+	public Matrix4f transform;
+	public Material material;
+	private int size;
+	
+	public Asset(){
+		texture = Texture.WOOD;
+		transform = new Matrix4f();
+		material = new DefaultMaterial();
+		vao = GL30.glGenVertexArrays();
+		vbo = GL15.glGenBuffers();
+		float[] a = new float[]{
+				//  X     Y     Z       U     V          Normal
+		        // bottom
+		        -1.0f,-1.0f,-1.0f,   0.0f, 0.0f,   0.0f, -1.0f, 0.0f,
+		         1.0f,-1.0f,-1.0f,   1.0f, 0.0f,   0.0f, -1.0f, 0.0f,
+		        -1.0f,-1.0f, 1.0f,   0.0f, 1.0f,   0.0f, -1.0f, 0.0f,
+		         1.0f,-1.0f,-1.0f,   1.0f, 0.0f,   0.0f, -1.0f, 0.0f,
+		         1.0f,-1.0f, 1.0f,   1.0f, 1.0f,   0.0f, -1.0f, 0.0f,
+		        -1.0f,-1.0f, 1.0f,   0.0f, 1.0f,   0.0f, -1.0f, 0.0f,
+
+		        // top
+		        -1.0f, 1.0f,-1.0f,   0.0f, 0.0f,   0.0f, 1.0f, 0.0f,
+		        -1.0f, 1.0f, 1.0f,   0.0f, 1.0f,   0.0f, 1.0f, 0.0f,
+		         1.0f, 1.0f,-1.0f,   1.0f, 0.0f,   0.0f, 1.0f, 0.0f,
+		         1.0f, 1.0f,-1.0f,   1.0f, 0.0f,   0.0f, 1.0f, 0.0f,
+		        -1.0f, 1.0f, 1.0f,   0.0f, 1.0f,   0.0f, 1.0f, 0.0f,
+		         1.0f, 1.0f, 1.0f,   1.0f, 1.0f,   0.0f, 1.0f, 0.0f,
+
+		        // front
+		        -1.0f,-1.0f, 1.0f,   1.0f, 0.0f,   0.0f, 0.0f, 1.0f,
+		         1.0f,-1.0f, 1.0f,   0.0f, 0.0f,   0.0f, 0.0f, 1.0f,
+		        -1.0f, 1.0f, 1.0f,   1.0f, 1.0f,   0.0f, 0.0f, 1.0f,
+		         1.0f,-1.0f, 1.0f,   0.0f, 0.0f,   0.0f, 0.0f, 1.0f,
+		         1.0f, 1.0f, 1.0f,   0.0f, 1.0f,   0.0f, 0.0f, 1.0f,
+		        -1.0f, 1.0f, 1.0f,   1.0f, 1.0f,   0.0f, 0.0f, 1.0f,
+
+		        // back
+		        -1.0f,-1.0f,-1.0f,   0.0f, 0.0f,   0.0f, 0.0f, -1.0f,
+		        -1.0f, 1.0f,-1.0f,   0.0f, 1.0f,   0.0f, 0.0f, -1.0f,
+		         1.0f,-1.0f,-1.0f,   1.0f, 0.0f,   0.0f, 0.0f, -1.0f,
+		         1.0f,-1.0f,-1.0f,   1.0f, 0.0f,   0.0f, 0.0f, -1.0f,
+		        -1.0f, 1.0f,-1.0f,   0.0f, 1.0f,   0.0f, 0.0f, -1.0f,
+		         1.0f, 1.0f,-1.0f,   1.0f, 1.0f,   0.0f, 0.0f, -1.0f,
+
+		        // left
+		        -1.0f,-1.0f, 1.0f,   0.0f, 1.0f,   -1.0f, 0.0f, 0.0f,
+		        -1.0f, 1.0f,-1.0f,   1.0f, 0.0f,   -1.0f, 0.0f, 0.0f,
+		        -1.0f,-1.0f,-1.0f,   0.0f, 0.0f,   -1.0f, 0.0f, 0.0f,
+		        -1.0f,-1.0f, 1.0f,   0.0f, 1.0f,   -1.0f, 0.0f, 0.0f,
+		        -1.0f, 1.0f, 1.0f,   1.0f, 1.0f,   -1.0f, 0.0f, 0.0f,
+		        -1.0f, 1.0f,-1.0f,   1.0f, 0.0f,   -1.0f, 0.0f, 0.0f,
+
+		        // right
+		         1.0f,-1.0f, 1.0f,   1.0f, 1.0f,   1.0f, 0.0f, 0.0f,
+		         1.0f,-1.0f,-1.0f,   1.0f, 0.0f,   1.0f, 0.0f, 0.0f,
+		         1.0f, 1.0f,-1.0f,   0.0f, 0.0f,   1.0f, 0.0f, 0.0f,
+		         1.0f,-1.0f, 1.0f,   1.0f, 1.0f,   1.0f, 0.0f, 0.0f,
+		         1.0f, 1.0f,-1.0f,   0.0f, 0.0f,   1.0f, 0.0f, 0.0f,
+		         1.0f, 1.0f, 1.0f,   0.0f, 1.0f,   1.0f, 0.0f, 0.0f
+		};
+		FloatBuffer buffer = BufferUtils.createFloatBuffer(a.length);
+		buffer.put(a).flip();
+		size = a.length/(3+2+3);
+		GL30.glBindVertexArray(vao);
+		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+		GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
+		
+		GL20.glEnableVertexAttribArray(Shaders.MAIN_LIGHT.getAttribLocation("vert"));
+		GL20.glVertexAttribPointer(Shaders.MAIN_LIGHT.getAttribLocation("vert"), 3, GL11.GL_FLOAT, false, 8*4, 0);
+		
+		GL20.glEnableVertexAttribArray(Shaders.MAIN_LIGHT.getAttribLocation("vertTexCoord"));
+		GL20.glVertexAttribPointer(Shaders.MAIN_LIGHT.getAttribLocation("vertTexCoord"), 2, GL11.GL_FLOAT, true, 8*4, 3*4);
+		
+		GL20.glEnableVertexAttribArray(Shaders.MAIN_LIGHT.getAttribLocation("vertNormal"));
+		GL20.glVertexAttribPointer(Shaders.MAIN_LIGHT.getAttribLocation("vertNormal"), 3, GL11.GL_FLOAT, true, 8*4, 5*4);
+		
+		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);	
+		GL30.glBindVertexArray(0);
+	}
+	
+	public void render(ArrayList<Light> lights){
+		Shaders.MAIN_LIGHT.bind();
+		Shaders.MAIN_LIGHT.uniform("camera", Camera.matrix);
+		Shaders.MAIN_LIGHT.uniform("transform", transform);
+		Shaders.MAIN_LIGHT.uniform("projection", DisplayManager.projection);
+		Shaders.MAIN_LIGHT.uniform("materialTex", 0); //set to 0 because the texture will be bound to GL_TEXTURE0
+		Shaders.MAIN_LIGHT.uniform("materialShininess", material.shininess);
+		Shaders.MAIN_LIGHT.uniform("materialSpecularColor", material.specularColor);
+		Shaders.MAIN_LIGHT.uniform("numLights", lights.size());
+		Shaders.MAIN_LIGHT.uniform("cameraPosition", Camera.pos);
+		
+		for(int i = 0;i < lights.size();i++){
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].position", lights.get(i).position);
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].intensities", lights.get(i).intensities);
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].attenuation", lights.get(i).attenuation);
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].ambientCoefficient", lights.get(i).ambientCoefficient);
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].coneAngle", lights.get(i).coneAngle);
+			Shaders.MAIN_LIGHT.uniform("allLights["+i+"].coneDirection", lights.get(i).coneDirection);
+		}
+		
+		GL13.glActiveTexture(GL13.GL_TEXTURE0);
+		texture.bind();
+		
+		GL30.glBindVertexArray(vao);
+		GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, size);
+		GL30.glBindVertexArray(0);
+		texture.unbind();
+		Shaders.MAIN_LIGHT.unbind();
+	}
+	
+	public void destroy(){
+		GL15.glDeleteBuffers(vbo);
+		GL30.glBindVertexArray(vao);
+		texture.destroy();
+		transform = null;
+	}
+	
+}

Diffuse light/src/fr/technicalgames/render/Camera.java

@@ -0,0 +1,67 @@
+package fr.technicalgames.render;
+import static org.lwjgl.glfw.GLFW.*;
+
+import org.lwjgl.glfw.*;
+import org.lwjgl.opengl.*;
+
+import fr.technicalgames.*;
+import fr.technicalgames.input.*;
+import fr.technicalgames.math.*;
+
+
+
+public class Camera {
+
+	public static Matrix4f matrix = new Matrix4f();
+	public static final float SPEED = 1.0f;
+	public static final float sens = 0.5f;
+	public static float speed = 1.0f;
+
+
+	
+	public static Vector3f rot = new Vector3f();
+	public static Vector3f pos = new Vector3f();
+	
+	public static void update(){
+		speed = SPEED * Main.delta;
+		if(Input.isKey(GLFW_KEY_LEFT_CONTROL))speed *= 2.0f;
+		rot.x += -Input.getDMouse().getY() * sens;
+		rot.y += -Input.getDMouse().getX() * sens;
+		if(rot.x > 90)rot.x = 90;
+		if(rot.x < -90)rot.x = -90;
+		if(Input.isKey(GLFW.GLFW_KEY_W)){
+			pos.x += Mathf.cos(Mathf.toRadians(rot.y + 90)) * speed;
+			pos.z += Mathf.sin(Mathf.toRadians(rot.y + 90)) * speed;
+		}
+		if(Input.isKey(GLFW.GLFW_KEY_S)){
+			pos.x += -Mathf.cos(Mathf.toRadians(rot.y + 90)) * speed;
+			pos.z += -Mathf.sin(Mathf.toRadians(rot.y + 90)) * speed;
+		}
+		if(Input.isKey(GLFW.GLFW_KEY_A)){
+			pos.x += -Mathf.cos(Mathf.toRadians(rot.y)) * speed;
+			pos.z += -Mathf.sin(Mathf.toRadians(rot.y)) * speed;
+		}
+		if(Input.isKey(GLFW.GLFW_KEY_D)){
+			pos.x += Mathf.cos(Mathf.toRadians(rot.y)) * speed;
+			pos.z += Mathf.sin(Mathf.toRadians(rot.y)) * speed;
+		}
+		if(Input.isKey(GLFW.GLFW_KEY_LEFT_SHIFT)){
+			pos.y -= speed;
+		}
+		if(Input.isKey(GLFW.GLFW_KEY_SPACE)){
+			pos.y += speed;
+		}
+		if(Input.isKeyDown(GLFW_KEY_ESCAPE))glfwSetWindowShouldClose(Main.windowID, GL11.GL_TRUE);
+		if(Input.isButtonDown(0))glfwSetInputMode(Main.windowID, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+		if(Input.isButtonDown(1))glfwSetInputMode(Main.windowID, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+	}
+	
+	public static void transform(){
+		matrix.loadIdentity();
+		matrix.rotate(new Quaternion(new Vector3f(1,0,0),rot.x));
+		matrix.rotate(new Quaternion(new Vector3f(0,1,0),rot.y));
+		matrix.rotate(new Quaternion(new Vector3f(0,0,1),rot.z));
+		matrix.tranlate(-pos.x, -pos.y, -pos.z);
+	}
+	
+}

Diffuse light/src/fr/technicalgames/render/DisplayManager.java

@@ -0,0 +1,55 @@
+package fr.technicalgames.render;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import fr.technicalgames.*;
+import fr.technicalgames.math.*;
+
+public class DisplayManager {
+
+	public static Matrix4f projection = new Matrix4f();
+	
+	public static void clear(){
+	    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+	
+	public static void preRender2D(){
+		projection.loadIdentity();
+		projection.Ortho2D(0, Main.WIDTH, 0, Main.HEIGHT, -1, 1);
+		glEnable(GL_DEPTH_TEST);
+	    glDepthFunc(GL_LESS);
+	    glEnable(GL_BLEND);
+	    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	
+	public static void preRender3D(){
+		projection.loadIdentity();
+		projection.perspective(50.0f, (float)Main.WIDTH/(float)Main.HEIGHT, 0.1f,100.0f);
+		glEnable(GL_DEPTH_TEST);
+	    glDepthFunc(GL_LESS);
+	    glEnable(GL_BLEND);
+	    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	
+	public static void preRenderGUI(){
+		projection.loadIdentity();
+		projection.Ortho2D(0, Main.WIDTH, 0, Main.HEIGHT, -1, 1);
+		glEnable(GL_DEPTH_TEST);
+	    glDepthFunc(GL_LESS);
+	    glEnable(GL_BLEND);
+	    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	
+	public static void render2D(){
+		Main.game.render2D();
+	}
+	
+	public static void render3D(){
+		Main.game.render3D();
+	}
+	
+	public static void renderGUI(){
+		Main.game.renderGUI();
+	}
+	
+}

Diffuse light/src/fr/technicalgames/render/Shaders.java

@@ -0,0 +1,96 @@
+package fr.technicalgames.render;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL20.*;
+
+import fr.technicalgames.input.*;
+import fr.technicalgames.math.*;
+
+public class Shaders {
+	
+	public int program;
+	
+	public static Shaders MAIN_LIGHT;
+	
+	static{
+		try {
+			MAIN_LIGHT = new Shaders("res/shaders/light.vert","res/shaders/light.frag");
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public Shaders(String vertexFile,String fragmentFile) throws Exception{
+		String fragmentShader = IO.loadFile(fragmentFile);
+		String vertexShader = IO.loadFile(vertexFile);
+		
+		if(program  != -1)glDeleteProgram(program);
+		program = glCreateProgram();
+		int vert = glCreateShader(GL_VERTEX_SHADER);
+		int frag = glCreateShader(GL_FRAGMENT_SHADER);
+		glShaderSource(vert, vertexShader);
+		glShaderSource(frag, fragmentShader);
+		glCompileShader(vert);
+		if (glGetShaderi(vert, GL_COMPILE_STATUS) == GL_FALSE) {
+			System.err.println(glGetShaderInfoLog(vert, 2048));
+			System.exit(1);
+		}else{
+			System.out.println("Vertex compiled !");
+		}
+		glCompileShader(frag);
+		if (glGetShaderi(frag, GL_COMPILE_STATUS) == GL_FALSE) {
+			System.err.println(glGetShaderInfoLog(frag, 2048));
+			System.exit(1);
+		}else{
+			System.out.println("Fragment compiled !");
+		}
+		glAttachShader(program, vert);
+		glAttachShader(program, frag);
+		glLinkProgram(program);
+		glValidateProgram(program);
+		glDeleteShader(frag);
+		glDeleteShader(vert);
+	}
+	
+	public void bind(){
+		glUseProgram(program);
+	}
+	
+	public void unbind(){
+		glUseProgram(0);
+	}
+	
+	public int getAttribLocation(String name){
+		return glGetAttribLocation(program, name);
+	}
+	
+	public void destroy(){
+		if(program == 0)return;
+		if(glIsProgram(program))unbind();
+		glDeleteProgram(program);
+	}
+	
+	public void uniform(String name,float v){
+		glUniform1f(glGetUniformLocation(program, name), v);
+	}
+	
+	public void uniform(String name,Vector3f vec){
+		glUniform3f(glGetUniformLocation(program, name), vec.x,vec.y,vec.z);
+	}
+	
+	public void uniform(String name,Vector4f vec){
+		glUniform4f(glGetUniformLocation(program, name), vec.x,vec.y,vec.z,vec.w);
+	}
+	
+	public void uniform(String name,Matrix4f mat){
+		glUniformMatrix4fv(glGetUniformLocation(program, name),true, mat.getBuffer());
+	}
+
+	public void uniform(String name, Color4f v) {
+		glUniform4f(glGetUniformLocation(program, name), v.getR(),v.getG(),v.getB(),v.getA());
+	}
+	
+	public void uniform(String name,int v){
+		glUniform1i(glGetUniformLocation(program,name), v);
+	}
+	
+}

Diffuse light/src/fr/technicalgames/render/Texture.java

@@ -0,0 +1,96 @@
+package fr.technicalgames.render;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL12.*;
+
+import java.awt.image.*;
+import java.io.*;
+import java.nio.*;
+
+import javax.imageio.*;
+
+import org.lwjgl.*;
+
+public class Texture {
+	
+	
+	public static Texture WOOD = loadTexture("res/textures/wooden-crate.jpg");
+
+	int width, height;
+	int id;
+	
+	public Texture(int width,int height,int id){
+		this.id = id;
+		this.width = width;
+		this.height = height;
+	}
+	
+	public static Texture loadTexture(String path){
+		try {
+			BufferedImage image = ImageIO.read(new File(path));
+			int width = image.getWidth();
+			int height = image.getHeight();
+			int[] pixels = new int[width * height];
+			
+			image.getRGB(0, 0, width, height, pixels, 0,width);
+			
+			int[] data = new int[pixels.length];
+			for (int i = 0; i < data.length; 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;
+			}
+			
+			IntBuffer buffer = BufferUtils.createIntBuffer(data.length);
+			buffer.put(data);
+			buffer.flip();
+			
+			int id = glGenTextures();
+			glBindTexture(GL_TEXTURE_2D, id);
+			
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+			
+			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, buffer);
+			
+			glBindTexture(GL_TEXTURE_2D, 0);
+			
+			System.out.println("Texture loaded ! " + width + "x" + height + " id:" + id);
+			
+			return new Texture(width, height, id);
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	public int getWidth() {
+		return width;
+	}
+
+	public int getHeight() {
+		return height;
+	}
+
+	public int getID(){
+		return id;
+	}
+	
+	public void bind(){
+		glBindTexture(GL_TEXTURE_2D, id);
+	}
+	
+	public void unbind(){
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
+	
+	public void destroy(){
+		glDeleteTextures(id);
+	}
+	
+}