diff --git a/.gitignore b/.gitignore
index 0a13c66..b4202cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,5 @@
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
+
+.idea/*
\ No newline at end of file
diff --git a/.idea/libraries/lwjgl.xml b/.idea/libraries/lwjgl.xml
new file mode 100644
index 0000000..d8302f5
--- /dev/null
+++ b/.idea/libraries/lwjgl.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index b1c9712..04c18b6 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -1,7 +1,13 @@
-
+
+
+
+
+
+
+
@@ -16,11 +22,109 @@
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
@@ -28,11 +132,47 @@
+
+
+ fr.technicalgames
+
+
+
+
+
+
+
+
@@ -59,27 +199,21 @@
-
-
-
-
-
-
-
+
-
+
-
+
-
+
@@ -87,7 +221,117 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -97,15 +341,21 @@
+
+
+
+
+
+
-
-
+
+
-
+
@@ -115,6 +365,61 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -130,6 +435,117 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -160,7 +576,7 @@
-
+
@@ -188,13 +604,291 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ No facets are configured
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1.8
+
+
+
+
+
+
+
+ GGL-2017
+
+
+
+
+
+
+
+ lwjgl
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/libs/OpenAL.dll b/libs/OpenAL.dll
new file mode 100644
index 0000000..f29c3ce
Binary files /dev/null and b/libs/OpenAL.dll differ
diff --git a/libs/OpenAL32.dll b/libs/OpenAL32.dll
new file mode 100644
index 0000000..31d639d
Binary files /dev/null and b/libs/OpenAL32.dll differ
diff --git a/libs/glfw.dll b/libs/glfw.dll
new file mode 100644
index 0000000..f8c3dc7
Binary files /dev/null and b/libs/glfw.dll differ
diff --git a/libs/glfw32.dll b/libs/glfw32.dll
new file mode 100644
index 0000000..3291dce
Binary files /dev/null and b/libs/glfw32.dll differ
diff --git a/libs/jemalloc.dll b/libs/jemalloc.dll
new file mode 100644
index 0000000..c71efc1
Binary files /dev/null and b/libs/jemalloc.dll differ
diff --git a/libs/jemalloc32.dll b/libs/jemalloc32.dll
new file mode 100644
index 0000000..6bea0b3
Binary files /dev/null and b/libs/jemalloc32.dll differ
diff --git a/libs/libglfw.dylib b/libs/libglfw.dylib
new file mode 100644
index 0000000..905c1bd
Binary files /dev/null and b/libs/libglfw.dylib differ
diff --git a/libs/libglfw.so b/libs/libglfw.so
new file mode 100644
index 0000000..e97463b
Binary files /dev/null and b/libs/libglfw.so differ
diff --git a/libs/libjemalloc.dylib b/libs/libjemalloc.dylib
new file mode 100644
index 0000000..1d7cc79
Binary files /dev/null and b/libs/libjemalloc.dylib differ
diff --git a/libs/libjemalloc.so b/libs/libjemalloc.so
new file mode 100644
index 0000000..dc95c65
Binary files /dev/null and b/libs/libjemalloc.so differ
diff --git a/libs/liblwjgl.dylib b/libs/liblwjgl.dylib
new file mode 100644
index 0000000..aeda823
Binary files /dev/null and b/libs/liblwjgl.dylib differ
diff --git a/libs/liblwjgl.so b/libs/liblwjgl.so
new file mode 100644
index 0000000..229b3c9
Binary files /dev/null and b/libs/liblwjgl.so differ
diff --git a/libs/libopenal.dylib b/libs/libopenal.dylib
new file mode 100644
index 0000000..7f0047b
Binary files /dev/null and b/libs/libopenal.dylib differ
diff --git a/libs/libopenal.so b/libs/libopenal.so
new file mode 100644
index 0000000..0c8e888
Binary files /dev/null and b/libs/libopenal.so differ
diff --git a/libs/lwjgl.dll b/libs/lwjgl.dll
new file mode 100644
index 0000000..8f385e5
Binary files /dev/null and b/libs/lwjgl.dll differ
diff --git a/libs/lwjgl32.dll b/libs/lwjgl32.dll
new file mode 100644
index 0000000..6177778
Binary files /dev/null and b/libs/lwjgl32.dll differ
diff --git a/src/com/company/Main.java b/src/com/company/Main.java
deleted file mode 100644
index d9d1a8b..0000000
--- a/src/com/company/Main.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.company;
-
-public class Main {
-
- public static void main(String[] args) {
- // write your code here
- }
-}
diff --git a/src/globalgamejam/Main.java b/src/globalgamejam/Main.java
new file mode 100644
index 0000000..84f0b6d
--- /dev/null
+++ b/src/globalgamejam/Main.java
@@ -0,0 +1,111 @@
+package globalgamejam;
+
+//http://www.tomdalling.com/blog/modern-opengl/08-even-more-lighting-directional-lights-spotlights-multiple-lights/
+
+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 globalgamejam.audio.*;
+import globalgamejam.game.*;
+import globalgamejam.input.*;
+import globalgamejam.math.*;
+import globalgamejam.render.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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 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())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, 3);
+ 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));
+ //------------------------------------------------------------------------------------
+
+ //Creation du device audio
+ //------------------------------------------------------------------------------------
+ Audio.create();
+ //------------------------------------------------------------------------------------
+
+ //initialisation
+ //------------------------------------------------------------------------------------
+ Input.init();
+ game = new MainGame();
+
+ Camera.transform();
+ //------------------------------------------------------------------------------------
+
+ while(glfwWindowShouldClose(windowID)){
+
+ 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.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();
+ }
+ }
+
+ Audio.destroy();
+ glfwDestroyWindow(windowID);
+ glfwTerminate();
+ }
+
+}
diff --git a/src/globalgamejam/audio/Audio.java b/src/globalgamejam/audio/Audio.java
new file mode 100644
index 0000000..dcffb88
--- /dev/null
+++ b/src/globalgamejam/audio/Audio.java
@@ -0,0 +1,325 @@
+package globalgamejam.audio;
+
+import static org.lwjgl.openal.AL.createCapabilities;
+import static org.lwjgl.openal.AL10.*;
+import static org.lwjgl.openal.ALC10.*;
+import static org.lwjgl.stb.STBVorbis.*;
+import static org.lwjgl.system.MemoryUtil.*;
+
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+
+import javax.sound.sampled.*;
+
+import org.lwjgl.*;
+import org.lwjgl.openal.*;
+
+
+import org.lwjgl.stb.STBVorbisInfo;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class Audio {
+
+ //Variables global
+ //------------------------------------------------------
+ public static long device;
+ public static ALCCapabilities caps;
+ public static long context;
+ public static final int INITIAL_STATE = 4113,PAUSED_STATE = 4115,STOPPED_STATE = 4116,PLAYING_STATE = 4114;
+ //------------------------------------------------------
+
+ //Variable de l'objet audio ou du son a lire
+ //------------------------------------------------------
+ private int buffer,source;
+ private String fileName;
+ private String format;
+ //------------------------------------------------------
+
+ //Fonction global
+ //------------------------------------------------------
+ public static void create(){
+ device = alcOpenDevice((ByteBuffer)null);
+ ALCCapabilities deviceCaps = ALC.createCapabilities(device);
+
+ context = alcCreateContext(device, (IntBuffer)null);
+ alcMakeContextCurrent(context);
+ createCapabilities(deviceCaps);
+ }
+
+ public static void destroy(){
+ alcCloseDevice(device);
+ alcDestroyContext(context);
+ }
+ //------------------------------------------------------
+
+ //Fonction de l'objet audio ou du son a lire
+ //------------------------------------------------------
+
+ public Audio(String fileName) throws Exception{
+ this.fileName = fileName;
+ setSound();
+ }
+
+ private void setSound() throws Exception{
+ if(fileName.endsWith(".ogg")){
+ loadOGGFormat();
+ format = "OGG";
+ }else if(fileName.endsWith(".wav")){
+ loadWavFormat();
+ format = "WAV";
+ }else{
+ throw new Exception("Format not supported !");
+ }
+ alSourcei(source, AL_BUFFER, buffer);
+ int size = alGetBufferi(buffer,AL_SIZE);
+ int bits = alGetBufferi(buffer, AL_BITS);
+ int channels = alGetBufferi(buffer, AL_CHANNELS);
+ int freq = alGetBufferi(buffer, AL_FREQUENCY);
+ System.out.println(fileName + " loaded !" + " | TIME : " + (size/channels/(bits/8)/freq) + "s | BITS : " + bits + " | CHANNELS : " + channels + " | FREQUENCE : " + freq + " FORMAT : " + format);
+ }
+
+ public void loadWavFormat() throws Exception{
+ AudioInputStream ais = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream(fileName)));
+ AudioFormat audioformat = ais.getFormat();
+
+ // get channels
+ int channels = 0;
+ if (audioformat.getChannels() == 1) {
+ if (audioformat.getSampleSizeInBits() == 8) {
+ channels = AL10.AL_FORMAT_MONO8;
+ } else if (audioformat.getSampleSizeInBits() == 16) {
+ channels = AL10.AL_FORMAT_MONO16;
+ } else {
+ assert false : "Illegal sample size";
+ }
+ } else if (audioformat.getChannels() == 2) {
+ if (audioformat.getSampleSizeInBits() == 8) {
+ channels = AL10.AL_FORMAT_STEREO8;
+ } else if (audioformat.getSampleSizeInBits() == 16) {
+ channels = AL10.AL_FORMAT_STEREO16;
+ } else {
+ assert false : "Illegal sample size";
+ }
+ } else {
+ assert false : "Only mono or stereo is supported";
+ }
+
+ int available = ais.available();
+ if(available <= 0) {
+ available = ais.getFormat().getChannels() * (int) ais.getFrameLength() * ais.getFormat().getSampleSizeInBits() / 8;
+ }
+ byte[] buf = new byte[ais.available()];
+ int read = 0, total = 0;
+ while ((read = ais.read(buf, total, buf.length - total)) != -1
+ && total < buf.length) {
+ total += read;
+ }
+ byte[] audio_bytes = buf;
+ boolean two_bytes_data = audioformat.getSampleSizeInBits() == 16;
+ ByteOrder order = audioformat.isBigEndian() ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
+ ByteBuffer dest = ByteBuffer.allocateDirect(audio_bytes.length);
+ dest.order(ByteOrder.nativeOrder());
+ ByteBuffer src = ByteBuffer.wrap(audio_bytes);
+ src.order(order);
+ if (two_bytes_data) {
+ ShortBuffer dest_short = dest.asShortBuffer();
+ ShortBuffer src_short = src.asShortBuffer();
+ while (src_short.hasRemaining())
+ dest_short.put(src_short.get());
+ } else {
+ while (src.hasRemaining())
+ dest.put(src.get());
+ }
+ dest.rewind();
+
+ this.buffer = alGenBuffers();
+ this.source = alGenSources();
+ alBufferData(this.buffer, channels, dest, (int)audioformat.getSampleRate());
+ dest.clear();
+ }
+
+ public void loadOGGFormat(){
+ STBVorbisInfo info = STBVorbisInfo.malloc();
+ ByteBuffer buff = BufferUtils.createByteBuffer(0);
+ //lecture du fichier
+ //----------------------------------------------------------------------------------------------------------------
+ try {
+ File file = new File(fileName);
+ if ( file.isFile() ) {
+ FileInputStream fis = new FileInputStream(file);
+ FileChannel fc = fis.getChannel();
+ buff = BufferUtils.createByteBuffer((int)fc.size() + 1);
+
+ while ( fc.read(buff) != -1 ) ;
+
+ fis.close();
+ fc.close();
+ } else {
+ System.err.println("File not found !");
+ return;
+ }
+
+ buff.flip();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ //----------------------------------------------------------------------------------------------------------------
+
+ IntBuffer error = BufferUtils.createIntBuffer(1);
+ long decoder = stb_vorbis_open_memory(buff, error, null);
+ if ( decoder == NULL )
+ throw new RuntimeException("Failed to open Ogg Vorbis file. Error: " + error.get(0));
+
+ stb_vorbis_get_info(decoder, info);
+
+ int channels = info.channels();
+
+ stb_vorbis_seek_start(decoder);
+ int lengthSamples = stb_vorbis_stream_length_in_samples(decoder);
+
+ ShortBuffer pcm = BufferUtils.createShortBuffer(lengthSamples * channels);
+
+ stb_vorbis_get_samples_short_interleaved(decoder, channels, pcm);
+ stb_vorbis_close(decoder);
+
+ buffer = alGenBuffers();
+
+ source = alGenSources();
+
+ if(channels == 1)alBufferData(buffer, AL_FORMAT_MONO16, pcm, info.sample_rate());
+ else alBufferData(buffer, AL_FORMAT_STEREO16, pcm, info.sample_rate());
+ }
+
+ public void playSound(){
+ if(source == 0 || buffer == 0) return;
+ alSourcePlay(source);
+ }
+
+ public int getPosition(){
+ return alGetSourcei(source, AL_POSITION);
+ }
+
+ public int getDurationInSeconds(){
+ if(source == 0 || buffer == 0) return 0;
+ int size = alGetBufferi(buffer,AL_SIZE);
+ int bits = alGetBufferi(buffer, AL_BITS);
+ int channels = alGetBufferi(buffer, AL_CHANNELS);
+ int freq = alGetBufferi(buffer, AL_FREQUENCY);
+ return size/channels/(bits/8)/freq;
+ }
+
+ public int getStateSound(){
+ if(source == 0 || buffer == 0) return 0;
+ return alGetSourcei(source, AL_SOURCE_STATE);
+ }
+
+ public boolean isStopped(){
+ if(source == 0 || buffer == 0) return false;
+ if(alGetSourcei(source, AL_SOURCE_STATE) == STOPPED_STATE)return true;
+ else return false;
+ }
+
+ public boolean isPaused(){
+ if(source == 0 || buffer == 0) return false;
+ if(alGetSourcei(source, AL_SOURCE_STATE) == PAUSED_STATE)return true;
+ else return false;
+ }
+
+ public boolean isPlaying(){
+ if(source == 0 || buffer == 0) return false;
+ if(alGetSourcei(source, AL_SOURCE_STATE) == PLAYING_STATE)return true;
+ else return false;
+ }
+
+ public boolean isInitial(){
+ if(source == 0 || buffer == 0) return false;
+ if(alGetSourcei(source, AL_SOURCE_STATE) == INITIAL_STATE)return true;
+ else return false;
+ }
+
+ public void stopSound(){
+ if(source == 0 || buffer == 0) return;
+ alSourceStop(source);
+ }
+
+ public void pauseSound(){
+ if(source == 0 || buffer == 0) return;
+ alSourcePause(source);
+ }
+
+ public void rewindSound(){
+ if(source == 0 || buffer == 0) return;
+ alSourceRewind(source);
+ }
+
+ public void setGain(float gain){
+ if(source == 0 || buffer == 0) return;
+ if(gain > 1.0f)gain = 1.0f;
+ if(gain < 0.0f)gain = 0.0f;
+ alSourcef(source, AL_GAIN, gain);
+ }
+
+ public void setPitch(float pitch){
+ if(source == 0 || buffer == 0) return;
+ if(pitch < 0.0f)pitch = 0.0f;
+ alSourcef(source, AL_PITCH, pitch);
+ }
+
+
+ public float getGain(){
+ if(source == 0 || buffer == 0) return 0;
+ return alGetSourcef(source, AL_GAIN);
+ }
+
+ public float getPitch(){
+ if(source == 0 || buffer == 0) return 0;
+ return alGetSourcef(source, AL_PITCH);
+ }
+
+ public void setLooping(boolean looping){
+ if(source == 0 || buffer == 0) return;
+ if(looping){
+ alSourcef(source, AL_LOOPING, AL_TRUE);
+ }else{
+ alSourcef(source, AL_LOOPING, AL_FALSE);
+ }
+ }
+
+ public void destroySound(){
+ alDeleteSources(source);
+ alDeleteBuffers(buffer);
+ source = 0;
+ buffer = 0;
+ }
+
+ public String getFileName() {
+ return fileName;
+ }
+
+ public void setFileName(String fileName) throws Exception {
+ this.fileName = fileName;
+ destroySound();
+ setSound();
+ }
+
+ public int getBuffer() {
+ return buffer;
+ }
+
+ public void setBuffer(int buffer) {
+ this.buffer = buffer;
+ }
+
+ public int getSource() {
+ return source;
+ }
+
+ public void setSource(int source) {
+ this.source = source;
+ }
+ //------------------------------------------------------
+
+}
diff --git a/src/globalgamejam/audio/Sound3D.java b/src/globalgamejam/audio/Sound3D.java
new file mode 100644
index 0000000..abd12a4
--- /dev/null
+++ b/src/globalgamejam/audio/Sound3D.java
@@ -0,0 +1,14 @@
+package globalgamejam.audio;
+
+import globalgamejam.math.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class Sound3D extends Audio{
+
+ public Sound3D(String fileName,Vector3f position) throws Exception {
+ super(fileName);
+ }
+
+}
diff --git a/src/globalgamejam/game/Game.java b/src/globalgamejam/game/Game.java
new file mode 100644
index 0000000..79528ba
--- /dev/null
+++ b/src/globalgamejam/game/Game.java
@@ -0,0 +1,23 @@
+package globalgamejam.game;
+
+import java.util.*;
+
+import globalgamejam.render.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public abstract class Game {
+
+ public Game(){
+ init();
+ }
+
+ public abstract void init();
+ public abstract void update();
+ public abstract void render2D();
+ public abstract void renderGUI();
+ public abstract void destroy();
+
+
+}
diff --git a/src/globalgamejam/game/MainGame.java b/src/globalgamejam/game/MainGame.java
new file mode 100644
index 0000000..99f64db
--- /dev/null
+++ b/src/globalgamejam/game/MainGame.java
@@ -0,0 +1,43 @@
+package globalgamejam.game;
+
+import globalgamejam.*;
+import globalgamejam.math.*;
+import globalgamejam.render.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class MainGame extends Game{
+
+ private float value = 0;
+
+ @Override
+ public void init() {
+
+
+ }
+
+ @Override
+ public void update() {
+ Camera.update();
+ Camera.transform();
+
+ }
+
+ @Override
+ public void render2D() {
+
+ }
+
+
+ @Override
+ public void renderGUI() {
+
+ }
+
+ @Override
+ public void destroy() {
+
+ }
+
+}
diff --git a/src/globalgamejam/input/IO.java b/src/globalgamejam/input/IO.java
new file mode 100644
index 0000000..c60955d
--- /dev/null
+++ b/src/globalgamejam/input/IO.java
@@ -0,0 +1,20 @@
+package globalgamejam.input;
+import java.io.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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;
+ }
+
+}
diff --git a/src/globalgamejam/input/Input.java b/src/globalgamejam/input/Input.java
new file mode 100644
index 0000000..dbe371b
--- /dev/null
+++ b/src/globalgamejam/input/Input.java
@@ -0,0 +1,248 @@
+package globalgamejam.input;
+
+
+import static org.lwjgl.glfw.GLFW.*;
+
+import java.util.*;
+import java.util.Map.*;
+
+import org.lwjgl.glfw.*;
+
+import globalgamejam.*;
+import globalgamejam.math.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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 state = new HashMap();
+
+ 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 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.free();
+ scroll.free();
+ }
+
+ 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 getState() {
+ return state;
+ }
+
+ public static void setState(HashMap 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;
+ }
+
+
+
+}
diff --git a/src/globalgamejam/math/Color4f.java b/src/globalgamejam/math/Color4f.java
new file mode 100644
index 0000000..f008e1f
--- /dev/null
+++ b/src/globalgamejam/math/Color4f.java
@@ -0,0 +1,113 @@
+package globalgamejam.math;
+
+
+import static org.lwjgl.opengl.GL11.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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();
+ }
+
+}
diff --git a/src/globalgamejam/math/Mathf.java b/src/globalgamejam/math/Mathf.java
new file mode 100644
index 0000000..ba462e8
--- /dev/null
+++ b/src/globalgamejam/math/Mathf.java
@@ -0,0 +1,70 @@
+package globalgamejam.math;
+
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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;
+ }
+
+}
diff --git a/src/globalgamejam/math/Matrix4f.java b/src/globalgamejam/math/Matrix4f.java
new file mode 100644
index 0000000..884dbc3
--- /dev/null
+++ b/src/globalgamejam/math/Matrix4f.java
@@ -0,0 +1,192 @@
+package globalgamejam.math;
+
+
+import java.nio.*;
+import java.util.*;
+
+import org.lwjgl.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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());
+ }
+
+}
diff --git a/src/globalgamejam/math/Quaternion.java b/src/globalgamejam/math/Quaternion.java
new file mode 100644
index 0000000..6d17388
--- /dev/null
+++ b/src/globalgamejam/math/Quaternion.java
@@ -0,0 +1,134 @@
+package globalgamejam.math;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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);
+ }
+
+}
diff --git a/src/globalgamejam/math/Vector2f.java b/src/globalgamejam/math/Vector2f.java
new file mode 100644
index 0000000..7e6d054
--- /dev/null
+++ b/src/globalgamejam/math/Vector2f.java
@@ -0,0 +1,45 @@
+package globalgamejam.math;
+
+
+import java.util.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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();
+ }
+}
diff --git a/src/globalgamejam/math/Vector3f.java b/src/globalgamejam/math/Vector3f.java
new file mode 100644
index 0000000..210b6d6
--- /dev/null
+++ b/src/globalgamejam/math/Vector3f.java
@@ -0,0 +1,107 @@
+package globalgamejam.math;
+
+
+import java.util.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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;
+ }
+
+}
diff --git a/src/globalgamejam/math/Vector4f.java b/src/globalgamejam/math/Vector4f.java
new file mode 100644
index 0000000..6fe52c2
--- /dev/null
+++ b/src/globalgamejam/math/Vector4f.java
@@ -0,0 +1,59 @@
+package globalgamejam.math;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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;
+ }
+
+
+
+
+}
diff --git a/src/globalgamejam/render/Camera.java b/src/globalgamejam/render/Camera.java
new file mode 100644
index 0000000..2dccf11
--- /dev/null
+++ b/src/globalgamejam/render/Camera.java
@@ -0,0 +1,36 @@
+package globalgamejam.render;
+import static org.lwjgl.glfw.GLFW.*;
+
+import org.lwjgl.glfw.*;
+import org.lwjgl.opengl.*;
+
+import globalgamejam.*;
+import globalgamejam.input.*;
+import globalgamejam.math.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class Camera {
+
+ public static Matrix4f matrix = new Matrix4f();
+ public static final float SPEED = 1.0f;//Speed de base
+
+
+
+ public static float rot = 0.0f;//rotation de la camera
+ public static Vector2f pos = new Vector2f();
+
+ public static void update(){
+ float speed = SPEED * Main.delta;//speed reel par frame en fonction des fps
+ //class Input pour tous ce qui est entrer et sortis
+
+ }
+
+ public static void transform(){
+ matrix.loadIdentity();
+ matrix.rotate(new Quaternion(new Vector3f(0,0,1),rot));
+ matrix.tranlate(-pos.x, -pos.y, 0);
+ }
+
+}
diff --git a/src/globalgamejam/render/DisplayManager.java b/src/globalgamejam/render/DisplayManager.java
new file mode 100644
index 0000000..79bffa3
--- /dev/null
+++ b/src/globalgamejam/render/DisplayManager.java
@@ -0,0 +1,46 @@
+package globalgamejam.render;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import globalgamejam.*;
+import globalgamejam.math.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+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 preRenderGUI(){
+ projection.loadIdentity();
+ //Permet de centrer la camera au centre de l'ecran
+ projection.Ortho2D(-Main.WIDTH/2.0f, Main.WIDTH/2.0f, -Main.HEIGHT/2.0f, Main.HEIGHT/2.0f, -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 renderGUI(){
+ Main.game.renderGUI();
+ }
+
+}
diff --git a/src/globalgamejam/render/Shaders.java b/src/globalgamejam/render/Shaders.java
new file mode 100644
index 0000000..b86f4ad
--- /dev/null
+++ b/src/globalgamejam/render/Shaders.java
@@ -0,0 +1,89 @@
+package globalgamejam.render;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL20.*;
+
+import globalgamejam.input.*;
+import globalgamejam.math.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class Shaders {
+
+ public int program;
+
+ 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);
+ }
+
+}
diff --git a/src/globalgamejam/render/Texture.java b/src/globalgamejam/render/Texture.java
new file mode 100644
index 0000000..f4f768c
--- /dev/null
+++ b/src/globalgamejam/render/Texture.java
@@ -0,0 +1,96 @@
+package globalgamejam.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.*;
+
+/**
+ * Class created by MrDev023 (Florian RICHER) on 14/01/2017
+ */
+public class Texture {
+
+ 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);
+ }
+
+}