commit 292abf9a577b44ad876ea7c4ac2c430b82169150 Author: Florian Richer (MrDev023) Date: Sun Mar 6 13:45:34 2016 +0100 First update diff --git a/Diffuse light/.classpath b/Diffuse light/.classpath new file mode 100644 index 0000000..bab40ed --- /dev/null +++ b/Diffuse light/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Diffuse light/.project b/Diffuse light/.project new file mode 100644 index 0000000..22ba6be --- /dev/null +++ b/Diffuse light/.project @@ -0,0 +1,17 @@ + + + Diffuse light + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/Diffuse light/bin/.gitignore b/Diffuse light/bin/.gitignore new file mode 100644 index 0000000..44fde90 --- /dev/null +++ b/Diffuse light/bin/.gitignore @@ -0,0 +1 @@ +/fr/ diff --git a/Diffuse light/res/shaders/light.frag b/Diffuse light/res/shaders/light.frag new file mode 100644 index 0000000..eec69e8 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/Diffuse light/res/shaders/light.vert b/Diffuse light/res/shaders/light.vert new file mode 100644 index 0000000..ee3c9f5 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/Diffuse light/res/textures/wooden-crate.jpg b/Diffuse light/res/textures/wooden-crate.jpg new file mode 100644 index 0000000..d1c8734 Binary files /dev/null and b/Diffuse light/res/textures/wooden-crate.jpg differ diff --git a/Diffuse light/src/fr/technicalgames/Main.java b/Diffuse light/src/fr/technicalgames/Main.java new file mode 100644 index 0000000..849b2c9 --- /dev/null +++ b/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(); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/game/Game.java b/Diffuse light/src/fr/technicalgames/game/Game.java new file mode 100644 index 0000000..a366624 --- /dev/null +++ b/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 assets = new ArrayList(); + public static ArrayList lights = new ArrayList(); + + 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(); + + +} diff --git a/Diffuse light/src/fr/technicalgames/game/MainGame.java b/Diffuse light/src/fr/technicalgames/game/MainGame.java new file mode 100644 index 0000000..9ac5666 --- /dev/null +++ b/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(); + } + } + +} diff --git a/Diffuse light/src/fr/technicalgames/input/IO.java b/Diffuse light/src/fr/technicalgames/input/IO.java new file mode 100644 index 0000000..eefd3c3 --- /dev/null +++ b/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; + } + +} diff --git a/Diffuse light/src/fr/technicalgames/input/Input.java b/Diffuse light/src/fr/technicalgames/input/Input.java new file mode 100644 index 0000000..c1ee0fe --- /dev/null +++ b/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 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.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 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/Diffuse light/src/fr/technicalgames/light/DirectionalLight.java b/Diffuse light/src/fr/technicalgames/light/DirectionalLight.java new file mode 100644 index 0000000..2693dd3 --- /dev/null +++ b/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() { + + } + + + +} diff --git a/Diffuse light/src/fr/technicalgames/light/Light.java b/Diffuse light/src/fr/technicalgames/light/Light.java new file mode 100644 index 0000000..8e2449f --- /dev/null +++ b/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; + } + + + +} diff --git a/Diffuse light/src/fr/technicalgames/light/SpotLight.java b/Diffuse light/src/fr/technicalgames/light/SpotLight.java new file mode 100644 index 0000000..5dba452 --- /dev/null +++ b/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() { + + } + +} diff --git a/Diffuse light/src/fr/technicalgames/material/DefaultMaterial.java b/Diffuse light/src/fr/technicalgames/material/DefaultMaterial.java new file mode 100644 index 0000000..9e6423f --- /dev/null +++ b/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)); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/material/Material.java b/Diffuse light/src/fr/technicalgames/material/Material.java new file mode 100644 index 0000000..060a32d --- /dev/null +++ b/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; + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Color4f.java b/Diffuse light/src/fr/technicalgames/math/Color4f.java new file mode 100644 index 0000000..aefea0d --- /dev/null +++ b/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(); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Mathf.java b/Diffuse light/src/fr/technicalgames/math/Mathf.java new file mode 100644 index 0000000..608de0a --- /dev/null +++ b/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; + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Matrix4f.java b/Diffuse light/src/fr/technicalgames/math/Matrix4f.java new file mode 100644 index 0000000..1ca1e24 --- /dev/null +++ b/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()); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Quaternion.java b/Diffuse light/src/fr/technicalgames/math/Quaternion.java new file mode 100644 index 0000000..4304585 --- /dev/null +++ b/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); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Vector2f.java b/Diffuse light/src/fr/technicalgames/math/Vector2f.java new file mode 100644 index 0000000..0543543 --- /dev/null +++ b/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(); + } +} diff --git a/Diffuse light/src/fr/technicalgames/math/Vector3f.java b/Diffuse light/src/fr/technicalgames/math/Vector3f.java new file mode 100644 index 0000000..5c78928 --- /dev/null +++ b/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; + } + +} diff --git a/Diffuse light/src/fr/technicalgames/math/Vector4f.java b/Diffuse light/src/fr/technicalgames/math/Vector4f.java new file mode 100644 index 0000000..bb869c2 --- /dev/null +++ b/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; + } + + + + +} diff --git a/Diffuse light/src/fr/technicalgames/render/Asset.java b/Diffuse light/src/fr/technicalgames/render/Asset.java new file mode 100644 index 0000000..64bff13 --- /dev/null +++ b/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 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; + } + +} diff --git a/Diffuse light/src/fr/technicalgames/render/Camera.java b/Diffuse light/src/fr/technicalgames/render/Camera.java new file mode 100644 index 0000000..1306752 --- /dev/null +++ b/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); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/render/DisplayManager.java b/Diffuse light/src/fr/technicalgames/render/DisplayManager.java new file mode 100644 index 0000000..1ce832b --- /dev/null +++ b/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(); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/render/Shaders.java b/Diffuse light/src/fr/technicalgames/render/Shaders.java new file mode 100644 index 0000000..93388fb --- /dev/null +++ b/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); + } + +} diff --git a/Diffuse light/src/fr/technicalgames/render/Texture.java b/Diffuse light/src/fr/technicalgames/render/Texture.java new file mode 100644 index 0000000..d70df7e --- /dev/null +++ b/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); + } + +}