GameDevArea/Java-Game-Engine-Light-Test
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Git Refactoring

Browse source
This commit is contained in:
MrDev023 2016-09-15 12:41:15 +02:00
parent c700911190
commit 55fcb82edd
35 changed files with 2338 additions and 2361 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored Normal file
View file

@ -0,0 +1,3 @@
bin/*
.project
.classpath

7
Diffuse light/.classpath
View file

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

17
Diffuse light/.project
View file

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

2
Diffuse light/bin/.gitignore vendored
View file

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

154
Diffuse light/res/shaders/light.frag → res/shaders/light.frag
View file

@ -1,78 +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);
#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);
}

44
Diffuse light/res/shaders/light.vert → res/shaders/light.vert
View file

@ -1,23 +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);
#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);
}

0
Diffuse light/res/textures/Thumbs.db → res/textures/Thumbs.db
View file

0
Diffuse light/res/textures/wooden-crate.jpg → res/textures/wooden-crate.jpg
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 49 KiB

After

Width:  |  Height:  |  Size: 49 KiB

226
Diffuse light/src/fr/technicalgames/Main.java → src/fr/technicalgames/Main.java
View file

@ -1,113 +1,113 @@
package fr.technicalgames;
//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 fr.technicalgames.audio.*;
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, 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.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();
}
}
Audio.destroy();
glfwDestroyWindow(windowID);
glfwTerminate();
}
}
package fr.technicalgames;
//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 fr.technicalgames.audio.*;
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, 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.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();
}
}
Audio.destroy();
glfwDestroyWindow(windowID);
glfwTerminate();
}
}

682
Diffuse light/src/fr/technicalgames/audio/Audio.java → src/fr/technicalgames/audio/Audio.java
View file

@ -1,341 +1,341 @@
package fr.technicalgames.audio;
import static org.lwjgl.openal.AL10.*;
import static org.lwjgl.openal.ALC10.*;
import static org.lwjgl.openal.ALC11.*;
import static org.lwjgl.openal.ALUtil.*;
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;
public abstract class Audio {
//Variables global
//------------------------------------------------------
public static ALDevice device;
public static ALCCapabilities caps;
public static ALContext 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 = ALDevice.create(null);
if ( device == null )
throw new IllegalStateException("Failed to open the default device.");
caps = device.getCapabilities();
System.out.println("---------------------------- Create Audio Device -------------------------------------");
System.out.println("OpenALC10: " + caps.OpenALC10);
System.out.println("OpenALC11: " + caps.OpenALC11);
System.out.println("caps.ALC_EXT_EFX = " + caps.ALC_EXT_EFX);
String defaultDeviceSpecifier = alcGetString(0L, ALC_DEFAULT_DEVICE_SPECIFIER);
System.out.println("Default device: " + defaultDeviceSpecifier);
context = ALContext.create(device);
System.out.println("ALC_FREQUENCY: " + alcGetInteger(device.address(), ALC_FREQUENCY) + "Hz");
System.out.println("ALC_REFRESH: " + alcGetInteger(device.address(), ALC_REFRESH) + "Hz");
System.out.println("ALC_SYNC: " + (alcGetInteger(device.address(), ALC_SYNC) == ALC_TRUE));
System.out.println("ALC_MONO_SOURCES: " + alcGetInteger(device.address(), ALC_MONO_SOURCES));
System.out.println("ALC_STEREO_SOURCES: " + alcGetInteger(device.address(), ALC_STEREO_SOURCES));
System.out.println("---------------------------------------------------------------------------------------");
}
public static void destroy(){
context.destroy();
device.destroy();
}
//------------------------------------------------------
//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);
checkALError();
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);
ByteBuffer pcm = BufferUtils.createByteBuffer(lengthSamples * 2 * channels);
stb_vorbis_get_samples_short_interleaved(decoder, channels, pcm, lengthSamples);
stb_vorbis_close(decoder);
buffer = alGenBuffers();
checkALError();
source = alGenSources();
checkALError();
if(channels == 1)alBufferData(buffer, AL_FORMAT_MONO16, pcm, info.sample_rate());
else alBufferData(buffer, AL_FORMAT_STEREO16, pcm, info.sample_rate());
checkALError();
}
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;
}
//------------------------------------------------------
}
package fr.technicalgames.audio;
import static org.lwjgl.openal.AL10.*;
import static org.lwjgl.openal.ALC10.*;
import static org.lwjgl.openal.ALC11.*;
import static org.lwjgl.openal.ALUtil.*;
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;
public abstract class Audio {
//Variables global
//------------------------------------------------------
public static ALDevice device;
public static ALCCapabilities caps;
public static ALContext 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 = ALDevice.create(null);
if ( device == null )
throw new IllegalStateException("Failed to open the default device.");
caps = device.getCapabilities();
System.out.println("---------------------------- Create Audio Device -------------------------------------");
System.out.println("OpenALC10: " + caps.OpenALC10);
System.out.println("OpenALC11: " + caps.OpenALC11);
System.out.println("caps.ALC_EXT_EFX = " + caps.ALC_EXT_EFX);
String defaultDeviceSpecifier = alcGetString(0L, ALC_DEFAULT_DEVICE_SPECIFIER);
System.out.println("Default device: " + defaultDeviceSpecifier);
context = ALContext.create(device);
System.out.println("ALC_FREQUENCY: " + alcGetInteger(device.address(), ALC_FREQUENCY) + "Hz");
System.out.println("ALC_REFRESH: " + alcGetInteger(device.address(), ALC_REFRESH) + "Hz");
System.out.println("ALC_SYNC: " + (alcGetInteger(device.address(), ALC_SYNC) == ALC_TRUE));
System.out.println("ALC_MONO_SOURCES: " + alcGetInteger(device.address(), ALC_MONO_SOURCES));
System.out.println("ALC_STEREO_SOURCES: " + alcGetInteger(device.address(), ALC_STEREO_SOURCES));
System.out.println("---------------------------------------------------------------------------------------");
}
public static void destroy(){
context.destroy();
device.destroy();
}
//------------------------------------------------------
//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);
checkALError();
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);
ByteBuffer pcm = BufferUtils.createByteBuffer(lengthSamples * 2 * channels);
stb_vorbis_get_samples_short_interleaved(decoder, channels, pcm, lengthSamples);
stb_vorbis_close(decoder);
buffer = alGenBuffers();
checkALError();
source = alGenSources();
checkALError();
if(channels == 1)alBufferData(buffer, AL_FORMAT_MONO16, pcm, info.sample_rate());
else alBufferData(buffer, AL_FORMAT_STEREO16, pcm, info.sample_rate());
checkALError();
}
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;
}
//------------------------------------------------------
}

22
Diffuse light/src/fr/technicalgames/audio/Sound3D.java → src/fr/technicalgames/audio/Sound3D.java
View file

@ -1,11 +1,11 @@
package fr.technicalgames.audio;
import fr.technicalgames.math.*;
public class Sound3D extends Audio{
public Sound3D(String fileName,Vector3f position) throws Exception {
super(fileName);
}
}
package fr.technicalgames.audio;
import fr.technicalgames.math.*;
public class Sound3D extends Audio{
public Sound3D(String fileName,Vector3f position) throws Exception {
super(fileName);
}
}

52
Diffuse light/src/fr/technicalgames/game/Game.java → src/fr/technicalgames/game/Game.java
View file

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

154
Diffuse light/src/fr/technicalgames/game/MainGame.java → src/fr/technicalgames/game/MainGame.java
View file

@ -1,77 +1,77 @@
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,5,-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 = new Asset();
as.transform = (new Matrix4f()).tranlate(-9, -10, -1).scale(20, .5f, 20);
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();
}
for(Light l : lights){
l.destroy();
}
}
}
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,5,-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 = new Asset();
as.transform = (new Matrix4f()).tranlate(-9, -10, -1).scale(20, .5f, 20);
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();
}
for(Light l : lights){
l.destroy();
}
}
}

34
Diffuse light/src/fr/technicalgames/input/IO.java → src/fr/technicalgames/input/IO.java
View file

@ -1,17 +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;
}
}
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;
}
}

490
Diffuse light/src/fr/technicalgames/input/Input.java → src/fr/technicalgames/input/Input.java
View file

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

36
Diffuse light/src/fr/technicalgames/light/DirectionalLight.java → src/fr/technicalgames/light/DirectionalLight.java
View file

@ -1,18 +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() {
}
}
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() {
}
}

152
Diffuse light/src/fr/technicalgames/light/Light.java → src/fr/technicalgames/light/Light.java
View file

@ -1,76 +1,76 @@
package fr.technicalgames.light;
import fr.technicalgames.math.*;
import fr.technicalgames.shadow.*;
public abstract class Light extends Shadow{
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){
super();
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;
}
}
package fr.technicalgames.light;
import fr.technicalgames.math.*;
import fr.technicalgames.shadow.*;
public abstract class Light extends Shadow{
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){
super();
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;
}
}

34
Diffuse light/src/fr/technicalgames/light/SpotLight.java → src/fr/technicalgames/light/SpotLight.java
View file

@ -1,17 +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() {
}
}
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() {
}
}

22
Diffuse light/src/fr/technicalgames/material/DefaultMaterial.java → src/fr/technicalgames/material/DefaultMaterial.java
View file

@ -1,11 +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));
}
}
package fr.technicalgames.material;
import fr.technicalgames.math.*;
public class DefaultMaterial extends Material{
public DefaultMaterial() {
super(80.0f, new Vector3f(1,1,1));
}
}

62
Diffuse light/src/fr/technicalgames/material/Material.java → src/fr/technicalgames/material/Material.java
View file

@ -1,31 +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;
}
}
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;
}
}

220
Diffuse light/src/fr/technicalgames/math/Color4f.java → src/fr/technicalgames/math/Color4f.java
View file

@ -1,110 +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();
}
}
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();
}
}

134
Diffuse light/src/fr/technicalgames/math/Mathf.java → src/fr/technicalgames/math/Mathf.java
View file

@ -1,67 +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;
}
}
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;
}
}

378
Diffuse light/src/fr/technicalgames/math/Matrix4f.java → src/fr/technicalgames/math/Matrix4f.java
View file

@ -1,189 +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());
}
}
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());
}
}

264
Diffuse light/src/fr/technicalgames/math/Quaternion.java → src/fr/technicalgames/math/Quaternion.java
View file

@ -1,132 +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);
}
}
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);
}
}

84
Diffuse light/src/fr/technicalgames/math/Vector2f.java → src/fr/technicalgames/math/Vector2f.java
View file

@ -1,42 +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();
}
}
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();
}
}

208
Diffuse light/src/fr/technicalgames/math/Vector3f.java → src/fr/technicalgames/math/Vector3f.java
View file

@ -1,104 +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;
}
}
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;
}
}

112
Diffuse light/src/fr/technicalgames/math/Vector4f.java → src/fr/technicalgames/math/Vector4f.java
View file

@ -1,56 +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;
}
}
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;
}
}

266
Diffuse light/src/fr/technicalgames/render/Asset.java → src/fr/technicalgames/render/Asset.java
View file

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

134
Diffuse light/src/fr/technicalgames/render/Camera.java → src/fr/technicalgames/render/Camera.java
View file

@ -1,67 +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);
}
}
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);
}
}

110
Diffuse light/src/fr/technicalgames/render/DisplayManager.java → src/fr/technicalgames/render/DisplayManager.java
View file

@ -1,55 +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();
}
}
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();
}
}

192
Diffuse light/src/fr/technicalgames/render/Shaders.java → src/fr/technicalgames/render/Shaders.java
View file

@ -1,96 +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);
}
}
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);
}
}

192
Diffuse light/src/fr/technicalgames/render/Texture.java → src/fr/technicalgames/render/Texture.java
View file

@ -1,96 +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);
}
}
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);
}
}

48
Diffuse light/src/fr/technicalgames/render/gui/GLFont.java → src/fr/technicalgames/render/gui/GLFont.java
View file

@ -1,24 +1,24 @@
package fr.technicalgames.render.gui;
import java.awt.*;
import java.awt.image.*;
import java.nio.*;
public class GLFont {
private Font font;
private int textureFont;
public GLFont(String name,int style,int size){
this.font = new Font(name, style, size);
}
public GLFont(){
this("Verdana",Font.BOLD,24);
}
}
package fr.technicalgames.render.gui;
import java.awt.*;
import java.awt.image.*;
import java.nio.*;
public class GLFont {
private Font font;
private int textureFont;
public GLFont(String name,int style,int size){
this.font = new Font(name, style, size);
}
public GLFont(){
this("Verdana",Font.BOLD,24);
}
}

18
Diffuse light/src/fr/technicalgames/render/gui/GUIComponent.java → src/fr/technicalgames/render/gui/GUIComponent.java
View file

@ -1,9 +1,9 @@
package fr.technicalgames.render.gui;
import fr.technicalgames.math.*;
public abstract class GUIComponent {
private Vector2f pos;
}
package fr.technicalgames.render.gui;
import fr.technicalgames.math.*;
public abstract class GUIComponent {
private Vector2f pos;
}

146
Diffuse light/src/fr/technicalgames/shadow/Shadow.java → src/fr/technicalgames/shadow/Shadow.java
View file

@ -1,73 +1,73 @@
package fr.technicalgames.shadow;
import org.lwjgl.opengl.*;
public class Shadow {
public static final int SIZE_OF_SHADOW_MAPPING = 1024;
private int frameBuffer;
private int depthTexture;
private boolean success = false;
public Shadow(){
//Creer et selectionne le buffer
// this.frameBuffer = GL30.glGenFramebuffers();
// GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, this.frameBuffer);
//
// //Creer la texture pour les ombres
// this.depthTexture = GL11.glGenTextures();
// GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.depthTexture);
// GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT16,SIZE_OF_SHADOW_MAPPING,SIZE_OF_SHADOW_MAPPING,0,GL11.GL_DEPTH_COMPONENT,GL11.GL_FLOAT,0);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
//
// GL32.glFramebufferTexture(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, depthTexture, 0);
// GL11.glDrawBuffer(GL11.GL_NONE);
// GL11.glReadBuffer(GL11.GL_NONE);
// if(GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER) == GL30.GL_FRAMEBUFFER_COMPLETE){
// success = true;
// }else{
// success = false;
// System.err.println("Shadow not adding to light");
// }
}
public void render(){
}
public void destroy(){
if(this.frameBuffer != 0)GL30.glDeleteFramebuffers(this.frameBuffer);
if(this.depthTexture != 0)GL11.glDeleteTextures(this.depthTexture);
}
public int getFrameBuffer() {
return frameBuffer;
}
public void setFrameBuffer(int frameBuffer) {
this.frameBuffer = frameBuffer;
}
public int getDepthTexture() {
return depthTexture;
}
public void setDepthTexture(int depthTexture) {
this.depthTexture = depthTexture;
}
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
}
package fr.technicalgames.shadow;
import org.lwjgl.opengl.*;
public class Shadow {
public static final int SIZE_OF_SHADOW_MAPPING = 1024;
private int frameBuffer;
private int depthTexture;
private boolean success = false;
public Shadow(){
//Creer et selectionne le buffer
// this.frameBuffer = GL30.glGenFramebuffers();
// GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, this.frameBuffer);
//
// //Creer la texture pour les ombres
// this.depthTexture = GL11.glGenTextures();
// GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.depthTexture);
// GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT16,SIZE_OF_SHADOW_MAPPING,SIZE_OF_SHADOW_MAPPING,0,GL11.GL_DEPTH_COMPONENT,GL11.GL_FLOAT,0);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
// GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
//
// GL32.glFramebufferTexture(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, depthTexture, 0);
// GL11.glDrawBuffer(GL11.GL_NONE);
// GL11.glReadBuffer(GL11.GL_NONE);
// if(GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER) == GL30.GL_FRAMEBUFFER_COMPLETE){
// success = true;
// }else{
// success = false;
// System.err.println("Shadow not adding to light");
// }
}
public void render(){
}
public void destroy(){
if(this.frameBuffer != 0)GL30.glDeleteFramebuffers(this.frameBuffer);
if(this.depthTexture != 0)GL11.glDeleteTextures(this.depthTexture);
}
public int getFrameBuffer() {
return frameBuffer;
}
public void setFrameBuffer(int frameBuffer) {
this.frameBuffer = frameBuffer;
}
public int getDepthTexture() {
return depthTexture;
}
public void setDepthTexture(int depthTexture) {
this.depthTexture = depthTexture;
}
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
}