From e0dbc755aadb94722ea53ebbbfaf75ed68872fa6 Mon Sep 17 00:00:00 2001 From: austin Date: Mon, 15 Mar 2021 01:01:42 -0400 Subject: [PATCH] First commit --- nbactions.xml | 17 + pom.xml | 149 +++++ .../java/RendererObjects/AnimChannel.java | 184 ++++++ src/main/java/RendererObjects/AnimNode.java | 26 + src/main/java/RendererObjects/Animation.java | 249 ++++++++ src/main/java/RendererObjects/Bone.java | 34 ++ src/main/java/RendererObjects/Camera.java | 39 ++ src/main/java/RendererObjects/Keyframe.java | 50 ++ .../Light/DirectionalLight.java | 74 +++ .../RendererObjects/Light/LightBuffer.java | 23 + .../RendererObjects/Light/PointLight.java | 106 ++++ .../java/RendererObjects/Light/SpotLight.java | 143 +++++ src/main/java/RendererObjects/Material.java | 67 +++ src/main/java/RendererObjects/Mesh.java | 537 +++++++++++++++++ src/main/java/RendererObjects/Model.java | 335 +++++++++++ .../java/RendererObjects/RenderUtils.java | 279 +++++++++ .../java/RendererObjects/ShaderProgram.java | 374 ++++++++++++ .../java/RendererObjects/texture/Texture.java | 136 +++++ .../RendererObjects/texture/TextureMap.java | 64 ++ src/main/java/audio/AudioEngine.java | 14 + src/main/java/entity/Entity.java | 37 ++ src/main/java/entity/EntityUtil.java | 45 ++ src/main/java/main/Globals.java | 93 +++ src/main/java/main/Main.java | 564 ++++++++++++++++++ src/main/java/net/Client.java | 14 + src/main/java/net/Server.java | 14 + src/main/java/util/ModelLoader.java | 85 +++ src/main/java/util/util.java | 234 ++++++++ src/main/resources/Models/ArenaSpire1.fbx | Bin 0 -> 16060 bytes src/main/resources/Models/MonorailSupport.fbx | Bin 0 -> 18396 bytes src/main/resources/Models/RailTrack1Part1.fbx | Bin 0 -> 27516 bytes src/main/resources/Models/Wheat1.fbx | Bin 0 -> 14876 bytes .../resources/Models/arcdock5deg1Try2.fbx | Bin 0 -> 15516 bytes .../resources/Models/arcdock5deg1notex.fbx | Bin 0 -> 13116 bytes .../resources/Models/groundplanemassiveuv.fbx | Bin 0 -> 11532 bytes src/main/resources/Models/plane.fbx | Bin 0 -> 11532 bytes src/main/resources/Models/skyscraper1.fbx | Bin 0 -> 15004 bytes src/main/resources/Models/tallbuilding1.fbx | Bin 0 -> 21628 bytes src/main/resources/Models/test3.fbx | Bin 0 -> 63548 bytes src/main/resources/Models/test5.fbx | Bin 0 -> 14764 bytes src/main/resources/Models/tree2.fbx | Bin 0 -> 32140 bytes src/main/resources/Shaders/FragmentShader.fs | 148 +++++ src/main/resources/Shaders/VertexShader.vs | 56 ++ .../resources/Shaders/VertexShaderNoBones.vs | 39 ++ .../Shaders/backup/FragmentShader.fs | 165 +++++ .../Shaders/backup/NewVertexShader.vs | 97 +++ src/main/resources/Shaders/old/LampShader.fs | 13 + .../resources/Shaders/old/VertexShader.vs | 68 +++ .../resources/Shaders/old/old shader code | 61 ++ .../resources/Shaders/old/oldFragShader.fs | 34 ++ .../Shaders/skybox/FragmentShaderNoTexture.fs | 13 + .../Shaders/skybox/VertexShaderNoTexture.vs | 34 ++ .../Textures/Fonts/OpenSansBitmap.bmp | Bin 0 -> 196662 bytes src/main/resources/Textures/Ground/Dirt1.png | Bin 0 -> 45406 bytes src/main/resources/Textures/Ground/Road1.png | Bin 0 -> 1187 bytes .../Textures/Ground/RoadIntersection1.png | Bin 0 -> 1199 bytes .../resources/Textures/MonorailSupport.png | Bin 0 -> 56824 bytes .../resources/Textures/RailTrack1Part1.png | Bin 0 -> 5986 bytes src/main/resources/Textures/Spaceplane.png | Bin 0 -> 30275 bytes .../resources/Textures/SpaceplaneSpecular.png | Bin 0 -> 16706 bytes src/main/resources/Textures/Wheat1stretch.png | Bin 0 -> 12900 bytes .../resources/Textures/default_diffuse.png | Bin 0 -> 967 bytes .../resources/Textures/default_specular.png | Bin 0 -> 967 bytes .../Textures/default_texture_map.json | 22 + src/main/resources/Textures/leaves.png | Bin 0 -> 71433 bytes .../Textures/skyscraper1_diffuse.png | Bin 0 -> 2327 bytes src/main/resources/Textures/trunk.png | Bin 0 -> 13272 bytes src/main/resources/Textures/w1.png | Bin 0 -> 165 bytes 68 files changed, 4736 insertions(+) create mode 100644 nbactions.xml create mode 100644 pom.xml create mode 100644 src/main/java/RendererObjects/AnimChannel.java create mode 100644 src/main/java/RendererObjects/AnimNode.java create mode 100644 src/main/java/RendererObjects/Animation.java create mode 100644 src/main/java/RendererObjects/Bone.java create mode 100644 src/main/java/RendererObjects/Camera.java create mode 100644 src/main/java/RendererObjects/Keyframe.java create mode 100644 src/main/java/RendererObjects/Light/DirectionalLight.java create mode 100644 src/main/java/RendererObjects/Light/LightBuffer.java create mode 100644 src/main/java/RendererObjects/Light/PointLight.java create mode 100644 src/main/java/RendererObjects/Light/SpotLight.java create mode 100644 src/main/java/RendererObjects/Material.java create mode 100644 src/main/java/RendererObjects/Mesh.java create mode 100644 src/main/java/RendererObjects/Model.java create mode 100644 src/main/java/RendererObjects/RenderUtils.java create mode 100644 src/main/java/RendererObjects/ShaderProgram.java create mode 100644 src/main/java/RendererObjects/texture/Texture.java create mode 100644 src/main/java/RendererObjects/texture/TextureMap.java create mode 100644 src/main/java/audio/AudioEngine.java create mode 100644 src/main/java/entity/Entity.java create mode 100644 src/main/java/entity/EntityUtil.java create mode 100644 src/main/java/main/Globals.java create mode 100644 src/main/java/main/Main.java create mode 100644 src/main/java/net/Client.java create mode 100644 src/main/java/net/Server.java create mode 100644 src/main/java/util/ModelLoader.java create mode 100644 src/main/java/util/util.java create mode 100644 src/main/resources/Models/ArenaSpire1.fbx create mode 100644 src/main/resources/Models/MonorailSupport.fbx create mode 100644 src/main/resources/Models/RailTrack1Part1.fbx create mode 100644 src/main/resources/Models/Wheat1.fbx create mode 100644 src/main/resources/Models/arcdock5deg1Try2.fbx create mode 100644 src/main/resources/Models/arcdock5deg1notex.fbx create mode 100644 src/main/resources/Models/groundplanemassiveuv.fbx create mode 100644 src/main/resources/Models/plane.fbx create mode 100644 src/main/resources/Models/skyscraper1.fbx create mode 100644 src/main/resources/Models/tallbuilding1.fbx create mode 100644 src/main/resources/Models/test3.fbx create mode 100644 src/main/resources/Models/test5.fbx create mode 100644 src/main/resources/Models/tree2.fbx create mode 100644 src/main/resources/Shaders/FragmentShader.fs create mode 100644 src/main/resources/Shaders/VertexShader.vs create mode 100644 src/main/resources/Shaders/VertexShaderNoBones.vs create mode 100644 src/main/resources/Shaders/backup/FragmentShader.fs create mode 100644 src/main/resources/Shaders/backup/NewVertexShader.vs create mode 100644 src/main/resources/Shaders/old/LampShader.fs create mode 100644 src/main/resources/Shaders/old/VertexShader.vs create mode 100644 src/main/resources/Shaders/old/old shader code create mode 100644 src/main/resources/Shaders/old/oldFragShader.fs create mode 100644 src/main/resources/Shaders/skybox/FragmentShaderNoTexture.fs create mode 100644 src/main/resources/Shaders/skybox/VertexShaderNoTexture.vs create mode 100644 src/main/resources/Textures/Fonts/OpenSansBitmap.bmp create mode 100644 src/main/resources/Textures/Ground/Dirt1.png create mode 100644 src/main/resources/Textures/Ground/Road1.png create mode 100644 src/main/resources/Textures/Ground/RoadIntersection1.png create mode 100644 src/main/resources/Textures/MonorailSupport.png create mode 100644 src/main/resources/Textures/RailTrack1Part1.png create mode 100644 src/main/resources/Textures/Spaceplane.png create mode 100644 src/main/resources/Textures/SpaceplaneSpecular.png create mode 100644 src/main/resources/Textures/Wheat1stretch.png create mode 100644 src/main/resources/Textures/default_diffuse.png create mode 100644 src/main/resources/Textures/default_specular.png create mode 100644 src/main/resources/Textures/default_texture_map.json create mode 100644 src/main/resources/Textures/leaves.png create mode 100644 src/main/resources/Textures/skyscraper1_diffuse.png create mode 100644 src/main/resources/Textures/trunk.png create mode 100644 src/main/resources/Textures/w1.png diff --git a/nbactions.xml b/nbactions.xml new file mode 100644 index 00000000..63a0e016 --- /dev/null +++ b/nbactions.xml @@ -0,0 +1,17 @@ + + + + run + + jar + + + process-classes + org.codehaus.mojo:exec-maven-plugin:1.5.0:exec + + + -classpath %classpath main.Main + java + + + diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..659f1d70 --- /dev/null +++ b/pom.xml @@ -0,0 +1,149 @@ + + + 4.0.0 + orbitalstudio + InfiniteStratos + 0.1 + jar + + UTF-8 + 11 + 11 + 3.2.3 + 1.9.19 + + + + + org.lwjgl + lwjgl + ${lwjgl.version} + + + org.lwjgl + lwjgl-assimp + ${lwjgl.version} + + + org.lwjgl + lwjgl-glfw + ${lwjgl.version} + + + org.lwjgl + lwjgl-opengl + ${lwjgl.version} + + + org.lwjgl + lwjgl-opengles + ${lwjgl.version} + + + org.lwjgl + lwjgl + ${lwjgl.version} + ${lwjgl.natives} + runtime + + + org.lwjgl + lwjgl-assimp + ${lwjgl.version} + ${lwjgl.natives} + runtime + + + org.lwjgl + lwjgl-glfw + ${lwjgl.version} + ${lwjgl.natives} + runtime + + + org.lwjgl + lwjgl-opengl + ${lwjgl.version} + ${lwjgl.natives} + runtime + + + org.lwjgl + lwjgl-opengles + ${lwjgl.version} + ${lwjgl.natives} + runtime + + + org.joml + joml + ${joml.version} + + + com.google.code.gson + gson + 2.8.6 + + + + + + lwjgl-natives-linux + + + unix + + + + natives-linux + + + + lwjgl-natives-macos + + + mac + + + + natives-macos + + + + lwjgl-natives-windows + + + windows + + + + natives-windows + + + + + + + ${basedir}/src/main/resources + + **/* + + + + + + maven-assembly-plugin + + + + main.Main + + + + jar-with-dependencies + + + + + + \ No newline at end of file diff --git a/src/main/java/RendererObjects/AnimChannel.java b/src/main/java/RendererObjects/AnimChannel.java new file mode 100644 index 00000000..74322414 --- /dev/null +++ b/src/main/java/RendererObjects/AnimChannel.java @@ -0,0 +1,184 @@ +package RendererObjects; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.ListIterator; +import org.joml.Matrix4f; +import org.joml.Quaternionf; +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class AnimChannel { + double timeCurrent; + double timeTotal; + public String nodeID; + + + public Vector3f startingPosition; + public ArrayList positionFrame; + public ListIterator positionFrameIterator; + Keyframe positionFrameCurrent; + Keyframe positionFrameNext; + double nextPositionTime; + + + public Quaternionf startingRotation; + public ArrayList rotationFrame; + public ListIterator rotationFrameIterator; + Keyframe rotationFrameCurrent; + Keyframe rotationFrameNext; + double nextRotationTime; + + + public ArrayList scaleFrame; + public ListIterator scaleFrameIterator; + Keyframe scaleFrameCurrent; + Keyframe scaleFrameNext; + double nextScaleTime; + + + public AnimChannel(double maxTime){ + timeTotal = maxTime; + } + + public Vector3f getCurrentPosition(){ + Vector3f rVal = new Vector3f(); + if(positionFrameCurrent != null){ + if(positionFrameNext != null){ + double percent_Next = ((timeCurrent - positionFrameCurrent.time) / (positionFrameNext.time - positionFrameCurrent.time)); + rVal = new Vector3f().add(new Vector3f().add(positionFrameCurrent.position).mul((float)(1.0 - percent_Next))).add(new Vector3f().add(positionFrameNext.position).mul((float)(percent_Next))); + } else { + rVal = new Vector3f().add(positionFrameCurrent.position); + } +// rVal.add(new Vector3f().add(positionFrameCurrent.position).mul(()/(positionFrameNext.time - positionFrameCurrent.time))); + } +// rVal = rVal.sub(startingPosition); + return rVal; + } + + public Quaternionf getCurrentRotation(){ + Quaternionf rVal = new Quaternionf(); + if(rotationFrameCurrent != null){ + if(rotationFrameNext != null){ + double percent_Next = ((timeCurrent - rotationFrameCurrent.time) / (rotationFrameNext.time - rotationFrameCurrent.time)); +// rVal = new Quaternionf(rotationFrameCurrent.rotation).normalize();//.add(rotationFrameCurrent.rotation); + rVal = new Quaternionf(rotationFrameCurrent.rotation).slerp(rotationFrameNext.rotation, (float)percent_Next); +// rVal = new Quaternionf(rotationFrameCurrent.rotation).normalize().slerp(new Quaternionf(rotationFrameNext.rotation).normalize(), (float)(percent_Next)).rotateAxis((float)(-Math.PI/2), new Vector3f(1,0,0)); + } else { + rVal = new Quaternionf(rotationFrameCurrent.rotation);//.add(rotationFrameCurrent.rotation); + } + } +// rVal = rVal.mul(new Quaternionf(startingRotation).invert()); + return rVal; + } + + public Vector3f getCurrentScale(){ + Vector3f rVal = new Vector3f(); + if(scaleFrameCurrent != null){ + if(scaleFrameNext != null){ + double percent_Next = ((timeCurrent - scaleFrameCurrent.time) / (scaleFrameNext.time - scaleFrameCurrent.time)); + rVal = new Vector3f().add(new Vector3f().add(scaleFrameCurrent.scale).mul((float)(1.0 - percent_Next))).add(new Vector3f().add(scaleFrameNext.scale).mul((float)(percent_Next))); + } else { + rVal = new Vector3f().add(scaleFrameCurrent.scale); + } +// rVal.add(new Vector3f().add(positionFrameCurrent.position).mul(()/(positionFrameNext.time - positionFrameCurrent.time))); + } + return rVal; + } + + public void incrementTime(double incrementValue){ + timeCurrent = timeCurrent + incrementValue; + while(positionFrameNext != null && timeCurrent > positionFrameNext.time){ + positionFrameCurrent = positionFrameNext; + if(positionFrameIterator.hasNext()){ + positionFrameNext = positionFrameIterator.next(); + } else { + positionFrameNext = null; + } + } + while(rotationFrameNext != null && timeCurrent > rotationFrameNext.time){ + rotationFrameCurrent = rotationFrameNext; + if(rotationFrameIterator.hasNext()){ + rotationFrameNext = rotationFrameIterator.next(); + } else { + rotationFrameNext = null; + } + } + while(scaleFrameNext != null && timeCurrent > scaleFrameNext.time){ + scaleFrameCurrent = scaleFrameNext; + if(scaleFrameIterator.hasNext()){ + scaleFrameNext = scaleFrameIterator.next(); + } else { + scaleFrameNext = null; + } + } + } + + public void rewind(){ + timeCurrent = 0; + + //TODO: Make sure has at least two frames + positionFrameIterator = positionFrame.listIterator(); + if(positionFrameIterator.hasNext()){ + positionFrameCurrent = positionFrameIterator.next(); + if(positionFrameIterator.hasNext()){ + positionFrameNext = positionFrameIterator.next(); + nextPositionTime = positionFrameNext.time; + } else { + positionFrameNext = null; + } + } + + rotationFrameIterator = rotationFrame.listIterator(); + if(rotationFrameIterator.hasNext()){ + rotationFrameCurrent = rotationFrameIterator.next(); + if(rotationFrameIterator.hasNext()){ + rotationFrameNext = rotationFrameIterator.next(); + } else { + rotationFrameNext = null; + } + } + + scaleFrameIterator = scaleFrame.listIterator(); + if(scaleFrameIterator.hasNext()){ + scaleFrameCurrent = scaleFrameIterator.next(); + if(scaleFrameIterator.hasNext()){ + scaleFrameNext = scaleFrameIterator.next(); + } else { + scaleFrameNext = null; + } + } + } + + public void describeChannel(){ + System.out.println("Target object: " + nodeID); + System.out.println("Time: " + timeCurrent + "/" + timeTotal); + System.out.println(positionFrame.size() + " position Frames"); + System.out.println(rotationFrame.size() + " rotation Frames"); + System.out.println(scaleFrame.size() + " scale Frames"); + } + + public void fullDescribeChannel(){ + System.out.println("Target object: " + nodeID); + System.out.println("Time: " + timeCurrent + "/" + timeTotal); + System.out.println(positionFrame.size() + " position Frames"); + Iterator frameIterator = positionFrame.iterator(); + while(frameIterator.hasNext()){ + System.out.println(frameIterator.next()); + } + System.out.println(rotationFrame.size() + " rotation Frames"); + frameIterator = rotationFrame.iterator(); + while(frameIterator.hasNext()){ + System.out.println(frameIterator.next()); + } + System.out.println(scaleFrame.size() + " scale Frames"); + frameIterator = scaleFrame.iterator(); + while(frameIterator.hasNext()){ + System.out.println(frameIterator.next()); + } + } + +} diff --git a/src/main/java/RendererObjects/AnimNode.java b/src/main/java/RendererObjects/AnimNode.java new file mode 100644 index 00000000..583261d6 --- /dev/null +++ b/src/main/java/RendererObjects/AnimNode.java @@ -0,0 +1,26 @@ +package RendererObjects; + +import java.util.ArrayList; +import org.joml.Matrix4f; +import org.lwjgl.assimp.AINode; + +/** + * + * @author amaterasu + */ +public class AnimNode { + public String id; + public Matrix4f transform; + public AnimNode parent; + public ArrayList children; + public boolean is_bone; + public AINode raw_data; + public AnimNode(String id, AnimNode parent, AINode raw_data){ + this.id = id; + this.parent = parent; + this.children = new ArrayList(); + this.transform = new Matrix4f(); + is_bone = false; + this.raw_data = raw_data; + } +} diff --git a/src/main/java/RendererObjects/Animation.java b/src/main/java/RendererObjects/Animation.java new file mode 100644 index 00000000..a8f4656e --- /dev/null +++ b/src/main/java/RendererObjects/Animation.java @@ -0,0 +1,249 @@ +package RendererObjects; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.PriorityQueue; +import org.joml.Quaternionf; +import org.joml.Vector3f; +import org.lwjgl.PointerBuffer; +import org.lwjgl.assimp.AIAnimation; +import org.lwjgl.assimp.AIMeshAnim; +import org.lwjgl.assimp.AIMeshKey; +import org.lwjgl.assimp.AINodeAnim; +import org.lwjgl.assimp.AIQuatKey; +import org.lwjgl.assimp.AIVectorKey; + +/** + * + * @author satellite + */ +public class Animation { + AIAnimation animData; + public String name; + public int ID; + ArrayList nodeChannelData; + ArrayList meshChannelData; + public ArrayList channels; + public double duration = 0; + public double timeCurrent = 0; + public double ticksPerSecond; + public Animation(AIAnimation animData, int ID){ + // + //Read in metadata + // + this.animData = animData; + name = animData.mName().dataString(); + this.duration = animData.mDuration(); + this.ticksPerSecond = animData.mTicksPerSecond(); + this.ID = ID; + // + //Print metadata + // +// System.out.println("Animation name: \"" + name + "\""); +// System.out.println("ID:(" + ID + ")"); +// System.out.println("Ticks per second: " + ticksPerSecond); +// System.out.println("Anim sizeof: " + animData.sizeof()); +// System.out.println("Duration: " + duration); + // + //Read in anim channels (bone modifications) + // + int channelCount = animData.mNumChannels(); + channels = new ArrayList(); + if(channelCount > 0){ +// System.out.println("Channel count: " + channelCount); + for(int i = 0; i < channelCount; i++){ + AINodeAnim currentChannelData = AINodeAnim.create(animData.mChannels().get(i)); +// System.out.println("Channel[" + (i + 1) + "]: " + currentChannelData.mNodeName().dataString()); + + //Create channel + AnimChannel currentChannel = new AnimChannel(duration); + currentChannel.positionFrame = new ArrayList(); + currentChannel.rotationFrame = new ArrayList(); + currentChannel.scaleFrame = new ArrayList(); + currentChannel.nodeID = currentChannelData.mNodeName().dataString(); + channels.add(currentChannel); + + + //get channel data + + if(currentChannelData.mNumPositionKeys() > 0){ + org.lwjgl.assimp.AIVectorKey.Buffer buff = currentChannelData.mPositionKeys(); +// Iterator keyIterator = buff.iterator(); +// while (keyIterator.hasNext()) { +// AIVectorKey key = keyIterator.next(); +// Keyframe currentFrame = new Keyframe(key.mTime()); +// currentFrame.position = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); +// currentChannel.positionFrame.add(currentFrame); +// } + if(buff != null && buff.hasRemaining()){ +// System.out.println("Position vectors: "); + AIVectorKey key = buff.get(); + Keyframe currentFrame = new Keyframe(key.mTime()); + currentFrame.position = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); + currentChannel.positionFrame.add(currentFrame); +// System.out.println(currentFrame.position); + currentChannel.startingPosition = currentFrame.position; + + Keyframe previousFrame; + while(buff.hasRemaining()){ + previousFrame = currentFrame; + key = buff.get(); + currentFrame = new Keyframe(key.mTime()); + currentFrame.position = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); +// System.out.println(currentFrame.position); + //check if duplicate +// Keyframe previousFrame = currentChannel.positionFrame.get(currentChannel.positionFrame.size() - 1); + if( previousFrame.position.x == currentFrame.position.x && + previousFrame.position.y == currentFrame.position.y && + previousFrame.position.z == currentFrame.position.z + ){ + } else { + currentChannel.positionFrame.add(currentFrame); + } + } + } + } + + if(currentChannelData.mNumRotationKeys() > 0){ + org.lwjgl.assimp.AIQuatKey.Buffer buff = currentChannelData.mRotationKeys(); + if(buff != null && buff.hasRemaining()){ + AIQuatKey key = buff.get(); + Keyframe currentFrame = new Keyframe(key.mTime()); + currentFrame.rotation = new Quaternionf(); + currentFrame.rotation.set(key.mValue().x(), key.mValue().y(), key.mValue().z(), key.mValue().w()); +// currentFrame.rotation = new Quaternionf(key.mValue().x(),key.mValue().y(),key.mValue().z(),key.mValue().w()); + currentChannel.rotationFrame.add(currentFrame); + + currentChannel.startingRotation = currentFrame.rotation; + + Keyframe previousFrame; + while(buff.hasRemaining()){ + previousFrame = currentFrame; + key = buff.get(); + currentFrame = new Keyframe(key.mTime()); + currentFrame.rotation = new Quaternionf(); + currentFrame.rotation.set(key.mValue().x(), key.mValue().y(), key.mValue().z(), key.mValue().w()); +// currentFrame.rotation = new Quaternionf(key.mValue().x(),key.mValue().y(),key.mValue().z(),key.mValue().w()); + //check for duplicate +// Keyframe previousFrame = currentChannel.rotationFrame.get(currentChannel.rotationFrame.size() - 1); + if( previousFrame.rotation.w == currentFrame.rotation.w && + previousFrame.rotation.x == currentFrame.rotation.x && + previousFrame.rotation.y == currentFrame.rotation.y && + previousFrame.rotation.z == currentFrame.rotation.z + ){ + } else { + currentChannel.rotationFrame.add(currentFrame); + } + } + } +// Iterator keyIterator = buff.iterator(); +// while(keyIterator.hasNext()){ +// AIQuatKey key = keyIterator.next(); +// Keyframe currentFrame = new Keyframe(key.mTime()); +// currentFrame.rotation = new Quaternionf(key.mValue().w(),key.mValue().x(),key.mValue().y(),key.mValue().z()); +// currentChannel.rotationFrame.add(currentFrame); +// } + } + + if(currentChannelData.mNumScalingKeys() > 0){ + org.lwjgl.assimp.AIVectorKey.Buffer buff = currentChannelData.mScalingKeys(); +// Iterator keyIterator = buff.iterator(); +// while (keyIterator.hasNext()) { +// AIVectorKey key = keyIterator.next(); +// Keyframe currentFrame = new Keyframe(key.mTime()); +// currentFrame.scale = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); +// currentChannel.scaleFrame.add(currentFrame); +// } + if(buff != null && buff.hasRemaining()){ + AIVectorKey key = buff.get(); + Keyframe currentFrame = new Keyframe(key.mTime()); + currentFrame.scale = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); + currentChannel.scaleFrame.add(currentFrame); + Keyframe previousFrame; + while(buff.hasRemaining()){ + previousFrame = currentFrame; + key = buff.get(); + currentFrame = new Keyframe(key.mTime()); + currentFrame.scale = new Vector3f(key.mValue().x(), key.mValue().y(), key.mValue().z()); + if( currentFrame.scale.x == previousFrame.scale.x && + currentFrame.scale.y == previousFrame.scale.y && + currentFrame.scale.z == previousFrame.scale.z + ){ + } else { + currentChannel.scaleFrame.add(currentFrame); + } + } + } + } + + +// System.out.println("end times"); +// for(int j = 0; j < currentChannelData.mNumPositionKeys(); j++){ +// org.lwjgl.assimp.AIVectorKey.Buffer buff = currentChannelData.mPositionKeys(); +// Iterator keyIterator = buff.iterator(); +// AIVectorKey posKey = currentChannelData.mPositionKeys().get(i); +// Keyframe currentFrame = new Keyframe(posKey.mTime()); +// currentFrame.position = new Vector3f(posKey.mValue().x(),posKey.mValue().y(),posKey.mValue().z()); +// } +// for(int j = 0; j < currentChannelData.mNumRotationKeys(); j++){ +// AIQuatKey rotKey = currentChannelData.mRotationKeys().get(i); +// HashMap test = new HashMap(); +// System.out.println(new Quaternionf(rotKey.mValue().w(),rotKey.mValue().x(),rotKey.mValue().y(),rotKey.mValue().z())); +// } +// for(int j = 0; j < currentChannelData.mNumScalingKeys(); j++){ +// AIVectorKey scaleKey = currentChannelData.mScalingKeys().get(i); +//// scaleKey.mValue(). +// System.out.println(new Vector3f(scaleKey.mValue().x(),scaleKey.mValue().y(),scaleKey.mValue().z())); +// } + } + } +// int meshChannelCount = animData.mNumMeshChannels(); +// meshChannelData = new ArrayList(); +// if(meshChannelCount > 0){ +// for(int i = 0; i < meshChannelCount; i++){ +// AIMeshAnim test = AIMeshAnim.create(animData.mMeshChannels().get(i)); +// } +// } + //gotta free things + nodeChannelData = null; + meshChannelData = null; + } + public void describeAnimation(){ + System.out.println("====================="); + System.out.println("Name: \"" + name + "\""); + System.out.println("ID: " + ID); + System.out.println("Duration: " + duration); + System.out.println("Ticks per second: " + ticksPerSecond); + Iterator channelIterator = channels.iterator(); + while(channelIterator.hasNext()){ + AnimChannel channelCurrent = channelIterator.next(); + System.out.println("====================="); + channelCurrent.describeChannel(); + } + System.out.println("====================="); + } + public void fullDescribeAnimation(){ + System.out.println("====================="); + System.out.println("Name: " + name); + System.out.println("ID: " + ID); + System.out.println("Duration: " + duration); + System.out.println("Ticks per second: " + ticksPerSecond); + Iterator channelIterator = channels.iterator(); + while(channelIterator.hasNext()){ + AnimChannel channelCurrent = channelIterator.next(); + System.out.println("====================="); + channelCurrent.fullDescribeChannel(); + } + System.out.println("====================="); + } + + public boolean incrementTime(double time){ + timeCurrent += time; + if(timeCurrent > duration){ + return true; + } else { + return false; + } + } +} diff --git a/src/main/java/RendererObjects/Bone.java b/src/main/java/RendererObjects/Bone.java new file mode 100644 index 00000000..a752dc97 --- /dev/null +++ b/src/main/java/RendererObjects/Bone.java @@ -0,0 +1,34 @@ +package RendererObjects; + +import java.util.ArrayList; +import java.util.HashMap; +import org.joml.Matrix4f; +import org.lwjgl.assimp.AIBone; + +/** + * + * @author satellite + */ +public class Bone { + public String boneID; + int numWeights; + HashMap weights; + public Matrix4f inverseBindPoseMatrix; + public Matrix4f deform; + public Matrix4f transform; + public Matrix4f final_transform; + public AIBone raw_data; + public Bone(){ + transform = new Matrix4f(); + deform = new Matrix4f(); + final_transform = new Matrix4f(); + } + public Bone(AIBone raw_data){ + transform = new Matrix4f(); + deform = new Matrix4f(); + final_transform = new Matrix4f(); + boneID = raw_data.mName().dataString(); + inverseBindPoseMatrix = util.util.convertAIMatrix(raw_data.mOffsetMatrix()); + this.raw_data = raw_data; + } +} diff --git a/src/main/java/RendererObjects/Camera.java b/src/main/java/RendererObjects/Camera.java new file mode 100644 index 00000000..a19aaff4 --- /dev/null +++ b/src/main/java/RendererObjects/Camera.java @@ -0,0 +1,39 @@ +package RendererObjects; + +import org.joml.Matrix4f; +import org.joml.Quaternionf; +import org.joml.Vector3f; + +/** + * + * @author satellite + */ +public class Camera { + public Vector3f pos_Center = new Vector3f(0,0,0); +// public Vector3f pos_Front = new Vector3f(0,0,0); +// public Vector3f pos_Top = new Vector3f(0,0,0); + public Quaternionf rotation = new Quaternionf(); + public Camera(){ + + } + + public void apply_camera(Camera c){ + pos_Center = new Vector3f(c.pos_Center); + rotation = new Quaternionf(c.rotation); + } + + public Matrix4f get_view_matrix(){ + Matrix4f rVal = new Matrix4f(); +// rVal.setLookAt(pos_Center, pos_Front, pos_Top); + Vector3f up = new Vector3f(pos_Center); + //new Vector3f(pos_Center).add(new Quaternionf(rotation)..transform(new Vector3f(1,0,0))) + Vector3f up_modifier = new Vector3f(1,0,0); + Quaternionf up_transformation = new Quaternionf(rotation); + up_transformation.rotateAxis((float)Math.PI/2.0f, new Vector3f(up).cross(new Vector3f(0,1,0))); // the hard part is getting the axis in this logic to correspond to the vertical + up = up.add(up_transformation.transform(up_modifier)); + rVal.setLookAt(pos_Center, //where our camera is + new Vector3f(pos_Center).add(rotation.transform(new Vector3f(1,0,0))), //where our camera wants to look + up); //where "up" is relative to our camera + return rVal; + } +} diff --git a/src/main/java/RendererObjects/Keyframe.java b/src/main/java/RendererObjects/Keyframe.java new file mode 100644 index 00000000..0b4ea360 --- /dev/null +++ b/src/main/java/RendererObjects/Keyframe.java @@ -0,0 +1,50 @@ +package RendererObjects; + +import org.joml.Quaternionf; +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class Keyframe implements Comparable{ + double time; + Vector3f position; + Quaternionf rotation; + Vector3f scale; + + public Keyframe(double time){ + this.time = time; + } + + @Override + public int compareTo(Object t) { + if(time > ((Keyframe)t).getTime()){ + return 1; + } else if(time < ((Keyframe)t).getTime()){ + return -1; + } else { + return 0; + } + } + + public double getTime(){ + return time; + } + + @Override + public String toString(){ + String rVal = ""; + rVal = rVal + "[" + time + "]"; + if(position != null){ + rVal = rVal + " position:" + position.toString(); + } + if(rotation != null){ + rVal = rVal + " rotation:" + rotation.toString(); + } + if(scale != null){ + rVal = rVal + " scale:" + scale.toString(); + } + return rVal; + } +} diff --git a/src/main/java/RendererObjects/Light/DirectionalLight.java b/src/main/java/RendererObjects/Light/DirectionalLight.java new file mode 100644 index 00000000..567282af --- /dev/null +++ b/src/main/java/RendererObjects/Light/DirectionalLight.java @@ -0,0 +1,74 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects.Light; + +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class DirectionalLight { + Vector3f direction; + + Vector3f ambient; + Vector3f diffuse; + Vector3f specular; + + public void setDirection(Vector3f direction) { + this.direction = direction; + } + + public void setAmbient(Vector3f ambient) { + this.ambient = ambient; + } + + public void setDiffuse(Vector3f diffuse) { + this.diffuse = diffuse; + } + + public void setSpecular(Vector3f specular) { + this.specular = specular; + } + + public Vector3f getDirection() { + return direction; + } + + public Vector3f getAmbient() { + return ambient; + } + + public Vector3f getDiffuse() { + return diffuse; + } + + public Vector3f getSpecular() { + return specular; + } + + public DirectionalLight(Vector3f direction){ + this.direction = direction; + ambient = new Vector3f(0.05f, 0.05f, 0.05f); + diffuse = new Vector3f(0.4f, 0.4f, 0.4f); + specular = new Vector3f(0.5f, 0.5f, 0.5f); + this.direction.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } + + public DirectionalLight(Vector3f direction, Vector3f color){ + this.direction = direction; + ambient = new Vector3f( color.x * 0.05f, color.y * 0.05f, color.z * 0.05f); + diffuse = new Vector3f( color.x * 0.4f, color.y * 0.4f, color.z * 0.4f); + specular = new Vector3f(color.x * 0.5f, color.y * 0.5f, color.z * 0.5f); + this.direction.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } +} diff --git a/src/main/java/RendererObjects/Light/LightBuffer.java b/src/main/java/RendererObjects/Light/LightBuffer.java new file mode 100644 index 00000000..984790dd --- /dev/null +++ b/src/main/java/RendererObjects/Light/LightBuffer.java @@ -0,0 +1,23 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects.Light; + +import static org.lwjgl.opengl.GL15.*; +import static org.lwjgl.opengl.GL31.GL_UNIFORM_BUFFER; + +/** + * + * @author amaterasu + */ +public class LightBuffer { + int light_uniform_buffer_address; + + public LightBuffer(){ + light_uniform_buffer_address = glGenBuffers(); + glBindBuffer(GL_UNIFORM_BUFFER,light_uniform_buffer_address); + //glBufferData(GL_UNIFORM_BUFFER, , GL_STATIC_DRAW); + } +} diff --git a/src/main/java/RendererObjects/Light/PointLight.java b/src/main/java/RendererObjects/Light/PointLight.java new file mode 100644 index 00000000..425f85ea --- /dev/null +++ b/src/main/java/RendererObjects/Light/PointLight.java @@ -0,0 +1,106 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects.Light; + +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class PointLight { + Vector3f position; + float constant; + float linear; + float quadratic; + Vector3f ambient; + Vector3f diffuse; + Vector3f specular; + + public void setPosition(Vector3f position) { + this.position = position; + } + + public void setConstant(float constant) { + this.constant = constant; + } + + public void setLinear(float linear) { + this.linear = linear; + } + + public void setQuadratic(float quadratic) { + this.quadratic = quadratic; + } + + public void setAmbient(Vector3f ambient) { + this.ambient = ambient; + } + + public void setDiffuse(Vector3f diffuse) { + this.diffuse = diffuse; + } + + public void setSpecular(Vector3f specular) { + this.specular = specular; + } + + public Vector3f getPosition() { + return position; + } + + public float getConstant() { + return constant; + } + + public float getLinear() { + return linear; + } + + public float getQuadratic() { + return quadratic; + } + + public Vector3f getAmbient() { + return ambient; + } + + public Vector3f getDiffuse() { + return diffuse; + } + + public Vector3f getSpecular() { + return specular; + } + + public PointLight(Vector3f position){ + this.position = position; + constant = 1.0f; + linear = 0.01f; + quadratic = 0.01f; + ambient = new Vector3f(0.05f, 0.05f, 0.05f); + diffuse = new Vector3f(0.8f, 0.8f, 0.8f); + specular = new Vector3f(1.0f, 1.0f, 1.0f); + this.position.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } + + public PointLight(Vector3f position, Vector3f color){ + this.position = position; + constant = 1.0f; + linear = 0.01f; + quadratic = 0.01f; + ambient = new Vector3f(color.x * 0.05f, color.y * 0.05f, color.z * 0.05f); + diffuse = new Vector3f(color.x * 0.8f, color.y * 0.8f, color.z * 0.8f); + specular = new Vector3f(color.x, color.y, color.z); + this.position.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } +} diff --git a/src/main/java/RendererObjects/Light/SpotLight.java b/src/main/java/RendererObjects/Light/SpotLight.java new file mode 100644 index 00000000..8ccbd174 --- /dev/null +++ b/src/main/java/RendererObjects/Light/SpotLight.java @@ -0,0 +1,143 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects.Light; + +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class SpotLight { + Vector3f position; + Vector3f direction; + float cutOff; + float outerCutOff; + + float constant; + float linear; + float quadratic; + + Vector3f ambient; + Vector3f diffuse; + Vector3f specular; + + public void setPosition(Vector3f position) { + this.position = position; + } + + public void setDirection(Vector3f direction) { + this.direction = direction; + } + + public void setCutOff(float cutOff) { + this.cutOff = cutOff; + } + + public void setOuterCutOff(float outerCutOff) { + this.outerCutOff = outerCutOff; + } + + public void setConstant(float constant) { + this.constant = constant; + } + + public void setLinear(float linear) { + this.linear = linear; + } + + public void setQuadratic(float quadratic) { + this.quadratic = quadratic; + } + + public void setAmbient(Vector3f ambient) { + this.ambient = ambient; + } + + public void setDiffuse(Vector3f diffuse) { + this.diffuse = diffuse; + } + + public void setSpecular(Vector3f specular) { + this.specular = specular; + } + + public Vector3f getPosition() { + return position; + } + + public Vector3f getDirection() { + return direction; + } + + public float getCutOff() { + return cutOff; + } + + public float getOuterCutOff() { + return outerCutOff; + } + + public float getConstant() { + return constant; + } + + public float getLinear() { + return linear; + } + + public float getQuadratic() { + return quadratic; + } + + public Vector3f getAmbient() { + return ambient; + } + + public Vector3f getDiffuse() { + return diffuse; + } + + public Vector3f getSpecular() { + return specular; + } + + + + public SpotLight(Vector3f position, Vector3f direction){ + this.position = position; + this.direction = direction; + cutOff = (float)Math.toRadians(12.5f); + outerCutOff = (float)Math.toRadians(15.0f); + constant = 1.0f; + linear = 0.01f; + quadratic = 0.01f; + ambient = new Vector3f(0.05f, 0.05f, 0.05f); + diffuse = new Vector3f(0.8f, 0.8f, 0.8f); + specular = new Vector3f(1.0f, 1.0f, 1.0f); + this.position.normalize(); + this.direction.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } + + public SpotLight(Vector3f position, Vector3f direction, Vector3f color){ + this.position = position; + this.direction = direction; + constant = 1.0f; + linear = 0.01f; + quadratic = 0.01f; + ambient = new Vector3f(color.x * 0.05f, color.y * 0.05f, color.z * 0.05f); + diffuse = new Vector3f(color.x * 0.8f, color.y * 0.8f, color.z * 0.8f); + specular = new Vector3f(color.x, color.y, color.z); + this.position.normalize(); + this.direction.normalize(); + ambient.normalize(); + diffuse.normalize(); + specular.normalize(); + } +} diff --git a/src/main/java/RendererObjects/Material.java b/src/main/java/RendererObjects/Material.java new file mode 100644 index 00000000..59502d92 --- /dev/null +++ b/src/main/java/RendererObjects/Material.java @@ -0,0 +1,67 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects; + +import RendererObjects.texture.Texture; +import org.lwjgl.PointerBuffer; +import org.lwjgl.assimp.AIMaterial; +import org.lwjgl.assimp.AIMaterialProperty; + +/** + * + * @author amaterasu + */ +public class Material { + Texture diffuse; + Texture specular; + boolean hasTransparency = false; + public Material(){ + + } + //basically useless because blender doesn't support exporting mats with fbx + public static Material load_material_from_aimaterial(AIMaterial input){ + Material rVal = new Material(); + if(input.mNumProperties() > 0){ + PointerBuffer property_buffer = input.mProperties(); + while(property_buffer.hasRemaining()){ + AIMaterialProperty new_property = AIMaterialProperty.create(property_buffer.get()); +// System.out.println("Property: " + new_property.mKey().dataString()); + } + } + return rVal; + } + public Texture get_diffuse(){ + return diffuse; + } + public Texture get_specular(){ + return specular; + } + public void set_diffuse(Texture t){ + diffuse = t; + if(t.isTransparent()){ + hasTransparency = true; + } + } + public void set_specular(Texture t){ + specular = t; + if(t.isTransparent()){ + hasTransparency = true; + } + } + + public void apply_material(){ + diffuse.bind(0); + specular.bind(1); + } + public void apply_material(int diffuse_channel, int specular_channel){ + diffuse.bind(diffuse_channel); + specular.bind(specular_channel); + } + + public boolean isTransparent(){ + return hasTransparency; + } +} diff --git a/src/main/java/RendererObjects/Mesh.java b/src/main/java/RendererObjects/Mesh.java new file mode 100644 index 00000000..4f100601 --- /dev/null +++ b/src/main/java/RendererObjects/Mesh.java @@ -0,0 +1,537 @@ +package RendererObjects; + +import main.Globals; +import main.Main; +import RendererObjects.Light.LightBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import org.joml.Matrix4f; +import org.joml.Vector3f; +import org.lwjgl.BufferUtils; +import org.lwjgl.PointerBuffer; +import org.lwjgl.assimp.AIBone; +import org.lwjgl.assimp.AIFace; +import org.lwjgl.assimp.AIMesh; +import org.lwjgl.assimp.AIVector2D; +import org.lwjgl.assimp.AIVector3D; +import org.lwjgl.assimp.AIVertexWeight; +import static org.lwjgl.opengl.ARBVertexBufferObject.*; +import org.lwjgl.opengl.GL11; +import static org.lwjgl.opengl.GL11.GL_FALSE; +import static org.lwjgl.opengl.GL11.GL_FLOAT; +import static org.lwjgl.opengl.GL11.GL_INT; +import static org.lwjgl.opengl.GL11.GL_TRIANGLES; +import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT; +import org.lwjgl.opengl.GL15; +import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER; +import static org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER; +import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW; +import static org.lwjgl.opengl.GL15.glBindBuffer; +import static org.lwjgl.opengl.GL15.glGenBuffers; +import org.lwjgl.opengl.GL20; +import static org.lwjgl.opengl.GL20.*; +import static org.lwjgl.opengl.GL20.glGetUniformLocation; +import static org.lwjgl.opengl.GL20.glUniform1i; +import static org.lwjgl.opengl.GL20.glUniform3fv; +import static org.lwjgl.opengl.GL20.glUniformMatrix4fv; +import static org.lwjgl.opengl.GL20.glUseProgram; +import static org.lwjgl.opengl.GL20.glVertexAttribPointer; +import static org.lwjgl.opengl.GL30.glBindVertexArray; +import static org.lwjgl.opengl.GL30.glGenVertexArrays; + +/** + * + * @author satellite + */ +public class Mesh { + public Model parent; + public String nodeID; + public AIMesh mesh; + public int vertexBuffer; + public int normalBuffer; + public int elementArrayBuffer; + public int elementCount; + public int faceCount; + public int vertexArrayObject; + public int vertexCount; + public int normalCount; + public int boneWeightBuffer; + public int boneIndexBuffer; + public int boneCount; + public int textureCoordBuffer; + public int textureCoordCount; + public ArrayList bones = new ArrayList(); + public ArrayList bone_id_list = new ArrayList(); + int bone_map_size = 0; + boolean hasBones = true; + public boolean hasTextureCoords = true; + + + public ShaderProgram shader; + + int shaderBoneArrayLocation; + + Material material; + + LightBuffer light_buffer; + + public static Mesh create_mesh_from_aimesh(AIMesh mesh){ + boolean has_bones = false; + boolean apply_lighting = true; + + Mesh rVal = new Mesh(); + rVal.mesh = mesh; + + // + // VAO + // + rVal.vertexArrayObject = glGenVertexArrays(); + glBindVertexArray(rVal.vertexArrayObject); + + + + //Basic checks + //check num vertices + int numVertices = 0; + AIVector3D.Buffer vertexData = mesh.mVertices(); + while(vertexData.hasRemaining()){ + vertexData.get(); + numVertices++; + } + vertexData = vertexData.rewind(); + //check num normals + int numNormals = 0; + AIVector3D.Buffer normalData = mesh.mNormals(); + while(normalData.hasRemaining()){ + normalData.get(); + numNormals++; + } + normalData.rewind(); + if(numVertices != numNormals){ + System.out.println("Catastrophic failure: Number of vertices =/= Number of normals"); + System.exit(1); + } + + + + + + + + + + + + + // + //Buffer data to GPU + // + vertexData.rewind(); + + try { + rVal.vertexCount = mesh.mNumVertices(); + FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(rVal.vertexCount * 3); + float[] temp = new float[3]; + for (int i = 0; i < rVal.vertexCount; i++) { + AIVector3D vertex = vertexData.get(); + temp[0] = vertex.x(); + temp[1] = vertex.y(); + temp[2] = vertex.z(); + VertexArrayBufferData.put(temp); + } + VertexArrayBufferData.flip(); + rVal.buffer_vertices(VertexArrayBufferData); + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + // + // NORMALS + // + AIVector3D.Buffer normals = mesh.mNormals(); + try { + rVal.normalCount = mesh.mNumVertices(); + FloatBuffer NormalArrayBufferData; + if(rVal.normalCount > 0){ + NormalArrayBufferData = BufferUtils.createFloatBuffer(rVal.normalCount * 3); + float[] temp = new float[3]; + for (int i = 0; i < rVal.normalCount; i++) { + AIVector3D normal = normals.get(i); + temp[0] = normal.x(); + temp[1] = normal.y(); + temp[2] = normal.z(); + NormalArrayBufferData.put(temp); + } + NormalArrayBufferData.flip(); + rVal.buffer_normals(NormalArrayBufferData); + } + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + // + // FACES + // + rVal.faceCount = mesh.mNumFaces(); + rVal.elementCount = rVal.faceCount * 3; + IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(rVal.elementCount); + AIFace.Buffer facesBuffer = mesh.mFaces(); + for(int i = 0; i < rVal.faceCount; i++){ + AIFace face = facesBuffer.get(i); + if(face.mNumIndices() != 3){ + throw new IllegalStateException("AIFace.mNumIndices() != 3"); + } + elementArrayBufferData.put(face.mIndices()); + } + elementArrayBufferData.flip(); + rVal.buffer_faces(elementArrayBufferData); + + + + + + // + // TEXTURE COORDINATES + // + if(mesh.mTextureCoords().capacity() > 0){ + AIVector3D.Buffer texturecoords = mesh.mTextureCoords(0); + try { + rVal.textureCoordCount = mesh.mTextureCoords(0).capacity(); + FloatBuffer TextureArrayBufferData; + if(rVal.textureCoordCount > 0){ + TextureArrayBufferData = BufferUtils.createFloatBuffer(rVal.textureCoordCount * 2); + float[] temp = new float[2]; + for (int i = 0; i < rVal.textureCoordCount; i++) { + AIVector3D normal = texturecoords.get(i); + temp[0] = normal.x(); + temp[1] = normal.y(); +// temp[2] = normal.z(); + TextureArrayBufferData.put(temp); + } + TextureArrayBufferData.flip(); + rVal.buffer_texture_coords(TextureArrayBufferData); + } + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + //System.out.println("Enabled texture coordinates"); + } + + + + + + + + + + + + + + // + //Read in bones + //AND buffer data (weights) to GPU + // + PointerBuffer boneBuffer = mesh.mBones(); + if(boneBuffer != null){ + has_bones = true; + while(boneBuffer.hasRemaining()){ + long currentAddr = boneBuffer.get(); + AIBone currentBoneData = AIBone.createSafe(currentAddr); +// System.out.println("Num weights: " + currentBoneData.mNumWeights()); + Bone currentBone = new Bone(); + currentBone.boneID = currentBoneData.mName().dataString(); + currentBone.inverseBindPoseMatrix = util.util.convertAIMatrix(currentBoneData.mOffsetMatrix()); + currentBone.numWeights = currentBoneData.mNumWeights(); + currentBone.weights = new HashMap(); + Iterator weightIterator = currentBoneData.mWeights().iterator(); + while(weightIterator.hasNext()){ + AIVertexWeight currentWeightData = weightIterator.next(); + currentBone.weights.put(currentWeightData.mVertexId(), currentWeightData.mWeight()); + } + rVal.bones.add(currentBone); + rVal.bone_id_list.add(currentBone.boneID); + } + rVal.boneCount = rVal.bones.size(); + FloatBuffer boneWeightDataBuffer = BufferUtils.createFloatBuffer(4 * rVal.vertexCount);//FloatBuffer.allocate(4 * vertexCount); + FloatBuffer boneIndexDataBuffer = BufferUtils.createFloatBuffer(4 * rVal.vertexCount);//IntBuffer.allocate(4 * vertexCount); + Iterator boneIterator; + for(int i = 0; i < rVal.vertexCount; i++){ + float[] weight = new float[4]; + float[] index = new float[4]; + int boneCounter = 0; + boneIterator = rVal.bones.iterator(); + while(boneIterator.hasNext()){ + Bone currentBone = boneIterator.next(); + float boneVal = 0; + if(currentBone.weights.get(i) != null){ + boneVal = currentBone.weights.get(i); + } + if(boneVal > 0){ + if(boneVal > weight[0]){ + weight[3] = weight[2]; + weight[2] = weight[1]; + weight[1] = weight[0]; + weight[0] = boneVal; + index[3] = index[2]; + index[2] = index[1]; + index[1] = index[0]; + index[0] = boneCounter; + } else if(boneVal > weight[1]){ + weight[3] = weight[2]; + weight[2] = weight[1]; + weight[1] = boneVal; + index[3] = index[2]; + index[2] = index[1]; + index[1] = boneCounter; + } else if(boneVal > weight[2]){ + weight[3] = weight[2]; + weight[2] = boneVal; + index[3] = index[2]; + index[2] = boneCounter; + } else if(boneVal > weight[3]){ + weight[3] = boneVal; + index[3] = boneCounter; + } + } + boneCounter++; + } + float total = weight[0] + weight[1] + weight[2] + weight[3]; + if(total != 1.0f){ + weight[0] = weight[0] * (1.0f / total); + weight[1] = weight[1] * (1.0f / total); + weight[2] = weight[2] * (1.0f / total); + weight[3] = weight[3] * (1.0f / total); + } + boneIndexDataBuffer.put(index); + boneWeightDataBuffer.put(weight); + } + boneIndexDataBuffer.flip(); + boneWeightDataBuffer.flip(); + + + rVal.boneWeightBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, rVal.boneWeightBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, boneWeightDataBuffer, GL_STATIC_DRAW); + glVertexAttribPointer(2, 4, GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(2); + + + rVal.boneIndexBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, rVal.boneIndexBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, boneIndexDataBuffer, GL_STATIC_DRAW); + glVertexAttribPointer(3, 4, GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(3); + } else { + rVal.hasBones = false; + } + + + + + + + + + + + + + rVal.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting); + + + + + + + + + + + + + + + + + glBindVertexArray(0); + + + + + + + + + + rVal.nodeID = mesh.mName().dataString(); + + + return rVal; + } + + + public Mesh(){ + + } + + public void draw() { + glUseProgram(shader.shaderProgram); + + //Until we switch to uniform buffer objects we will have to buffer lighting data here manually each time we draw + //side note: :( + if(light_buffer == null){ + float temp[] = new float[3]; + temp[0] = 0.2f; + temp[1] = -1.0f; + temp[2] = 0.3f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.direction"), temp); + + temp[0] = 0.1f; + temp[1] = 0.1f; + temp[2] = 0.1f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.ambient"), temp); + + temp[0] = 0.8f; + temp[1] = 0.8f; + temp[2] = 0.8f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.diffuse"), temp); + + temp[0] = 0.1f; + temp[1] = 0.1f; + temp[2] = 0.1f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.specular"), temp); + + temp[0] = 32f; + glUniform1fv(glGetUniformLocation(shader.shaderProgram, "material.shininess"), temp); + + GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "model"), false, parent.modelMatrix.get(new float[16])); + + Vector3f cam_Loc = Globals.camera_visible.pos_Center; + temp[0] = cam_Loc.x; + temp[1] = cam_Loc.y; + temp[2] = cam_Loc.z; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "viewPos"), temp); + } else { + GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "model"), false, parent.modelMatrix.get(new float[16])); + } + + + if(material == null){ + Globals.material_default.apply_material(0,1); + GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 0); + } else { + material.apply_material(); + if(material.hasTransparency){ + GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1); + } else { + GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1); + } + } + + glBindVertexArray(vertexArrayObject); + + + + + // + //Handle bones + // + if(bones != null && !bones.isEmpty()){ + glUniform1i(shader.shaderVertexHasBonesLoc, 1); + glUniform1i(shader.shaderVertexNumBonesLoc, bones.size()); + Iterator boneIterator = bone_id_list.iterator(); + float bufferarray[] = new float[16]; + int incrementer = 0; + while (boneIterator.hasNext()){ + Bone currentBone = parent.boneMap.get(boneIterator.next()); + Matrix4f currentMat = new Matrix4f(currentBone.final_transform); + currentMat.get(bufferarray); + String currentUniform = "bones[" + incrementer + "]"; + GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, currentUniform), false, bufferarray); + incrementer++; + } + } else { + glUniform1i(shader.shaderVertexHasBonesLoc, 0); + } + + + + //buffer model/view/proj matrices + glUniformMatrix4fv(shader.shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16])); + glUniformMatrix4fv(shader.shaderVertexViewLoc, false, Globals.viewMatrix.get(new float[16])); + glUniformMatrix4fv(shader.shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16])); + glUniform3fv(shader.shaderVertexViewPosLoc, Globals.camera_visible.pos_Center.get(BufferUtils.createFloatBuffer(3))); + + // + // + //Testing Lights + // + // + float test_Light_Data[] = new float[3]; + test_Light_Data[0] = 0.2f; + test_Light_Data[1] = -1.0f; + test_Light_Data[2] = 0.3f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.direction"), test_Light_Data); + + test_Light_Data = new float[3]; + test_Light_Data[0] = 0.3f; + test_Light_Data[1] = 0.3f; + test_Light_Data[2] = 0.3f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.ambient"), test_Light_Data); + + test_Light_Data = new float[3]; + test_Light_Data[0] = 0.5f; + test_Light_Data[1] = 0.5f; + test_Light_Data[2] = 0.5f; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.diffuse"), test_Light_Data); + + Vector3f cam_Loc = Globals.camera_visible.pos_Center; + test_Light_Data = new float[3]; + test_Light_Data[0] = cam_Loc.x; + test_Light_Data[1] = cam_Loc.y; + test_Light_Data[2] = cam_Loc.z; + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "viewPos"), test_Light_Data); + + + GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + } + + public void buffer_vertices(FloatBuffer verticies){ + vertexBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, verticies, GL_STATIC_DRAW); + glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(0); + } + + public void buffer_normals(FloatBuffer normals){ + normalBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, normalBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, normals, GL_STATIC_DRAW); + glVertexAttribPointer(1, 3, GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(1); + } + + public void buffer_faces(IntBuffer faces){ + elementArrayBuffer = glGenBuffers(); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBuffer); + GL15.glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces, GL_STATIC_DRAW); + elementCount = faces.capacity(); + } + + public void buffer_texture_coords(FloatBuffer coords){ + textureCoordBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, textureCoordBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, coords, GL_STATIC_DRAW); + glVertexAttribPointer(4, 2, GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(4); + } + + public void set_material(Material input){ + this.material = input; + } +} diff --git a/src/main/java/RendererObjects/Model.java b/src/main/java/RendererObjects/Model.java new file mode 100644 index 00000000..394aa616 --- /dev/null +++ b/src/main/java/RendererObjects/Model.java @@ -0,0 +1,335 @@ +package RendererObjects; + +import main.Globals; +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.ListIterator; +import org.joml.Matrix4f; +import org.joml.Vector3f; +import org.lwjgl.BufferUtils; +import org.lwjgl.PointerBuffer; +import org.lwjgl.assimp.AIMaterial; +import org.lwjgl.assimp.AIMesh; +import org.lwjgl.assimp.AIScene; +import static org.lwjgl.assimp.Assimp.*; +import static org.lwjgl.opengl.ARBVertexBufferObject.*; +import static org.lwjgl.opengl.ARBVertexProgram.*; +import org.lwjgl.opengl.GL11; +import static org.lwjgl.opengl.GL11.*; +import static org.lwjgl.opengl.GL13.*; +import static org.lwjgl.opengl.GL15.*; +import static org.lwjgl.opengl.GL20.*; +import static org.lwjgl.opengl.GL30.*; +import RendererObjects.texture.TextureMap; +import java.nio.FloatBuffer; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.Map; +import java.util.Stack; +import org.joml.Quaternionf; +import org.lwjgl.assimp.AIAnimation; +import org.lwjgl.assimp.AIBone; +import org.lwjgl.assimp.AINode; + +/** + * + * @author satellite + */ +public class Model { + public boolean is_Ready_To_Display = false; + public AIScene scene; + public ArrayList meshes; + public ArrayList animations; + public ArrayList bones; + public HashMap boneMap; + public HashMap node_map; + public ArrayList materials; + public Matrix4f modelMatrix = new Matrix4f(); + ShaderProgram program; + public Animation currentAnimation; + public Matrix4f globalInverseTransform; + + AnimNode root_anim_node; + + public static Model create_model_from_aiscene(AIScene s){ + Model rVal = new Model(); + // + //set the scene + // + rVal.scene = s; + + // + //load meshes + // + int meshCount = s.mNumMeshes(); + PointerBuffer meshesBuffer = s.mMeshes(); + rVal.meshes = new ArrayList(); + while(meshesBuffer.hasRemaining()){ + Mesh currentMesh = Mesh.create_mesh_from_aimesh(AIMesh.create(meshesBuffer.get())); + rVal.meshes.add(currentMesh); + currentMesh.parent = rVal; + } + // + //register bones + // + rVal.bones = new ArrayList(); + rVal.boneMap = new HashMap(); + meshesBuffer.rewind(); + while(meshesBuffer.hasRemaining()){ + AIMesh currentMeshData = AIMesh.createSafe(meshesBuffer.get()); + PointerBuffer boneBuffer = currentMeshData.mBones(); + for(int j = 0; j < currentMeshData.mNumBones(); j++){ + AIBone currentBone = AIBone.createSafe(boneBuffer.get()); + String currentBoneName = currentBone.mName().dataString(); + if(!rVal.boneMap.containsKey(currentBoneName)){ + Bone boneObject = new Bone(currentBone); + rVal.boneMap.put(currentBoneName, boneObject); + rVal.bones.add(boneObject); + } + } + } + Iterator meshIterator = rVal.meshes.iterator(); + rVal.bones = new ArrayList(); + rVal.boneMap = new HashMap(); + rVal.node_map = new HashMap(); + while(meshIterator.hasNext()){ + Mesh currentMesh = meshIterator.next(); + Iterator boneIterator = currentMesh.bones.iterator(); + ArrayList to_remove_queue = new ArrayList(); + ArrayList to_add_queue = new ArrayList(); + while(boneIterator.hasNext()){ + Bone currentBone = boneIterator.next(); + if(!rVal.boneMap.containsKey(currentBone.boneID)){ + rVal.bones.add(currentBone); + rVal.boneMap.put(currentBone.boneID, currentBone); + } + } + boneIterator = to_remove_queue.iterator(); + while(boneIterator.hasNext()){ + currentMesh.bones.remove(boneIterator.next()); + } + boneIterator = to_add_queue.iterator(); + while(boneIterator.hasNext()){ + currentMesh.bones.add(boneIterator.next()); + } + } + // + //parse animation nodes and form hierarchy + // + AINode rootNode = s.mRootNode(); + rVal.globalInverseTransform = util.util.convertAIMatrix(rootNode.mTransformation()); +// System.out.println("Global inverse transform"); +// System.out.println(globalInverseTransform); + rVal.root_anim_node = rVal.build_anim_node_map(s.mRootNode(),null); + // + //load animations + // + int animCount = s.mNumAnimations(); + PointerBuffer animBuffer = s.mAnimations(); + rVal.animations = new ArrayList(); + for(int i = 0; i < animCount; i++){ + rVal.animations.add(new Animation(AIAnimation.create(animBuffer.get(i)), i)); + } + // + //Load materials + // + if(s.mNumMaterials() > 0){ + rVal.materials = new ArrayList(); + PointerBuffer material_buffer = s.mMaterials(); + while(material_buffer.hasRemaining()){ + rVal.materials.add(Material.load_material_from_aimaterial(AIMaterial.create(material_buffer.get()))); + } + } + //garbage collect + System.gc(); + return rVal; + } + + + + public Model(){ + /* + public boolean is_Ready_To_Display = false; + public AIScene scene; + public ArrayList meshes; + public ArrayList animations; + public ArrayList bones; + public HashMap boneMap; + public HashMap node_map = new HashMap(); + public ArrayList materials; + public Matrix4f modelMatrix = new Matrix4f().translation(new Vector3f(0,0,0)); + ShaderProgram program; + public Animation currentAnimation; + public Matrix4f globalInverseTransform; + */ + scene = null; + meshes = null; + animations = null; + bones = null; + boneMap = null; + node_map = null; + materials = null; + modelMatrix = new Matrix4f(); + program = null; + currentAnimation = null; + globalInverseTransform = null; + } + + public void free() { + aiReleaseImport(scene); + scene = null; + meshes = null; + } + + public void draw(){ + if(node_map != null && !node_map.isEmpty()){ + update_node_transform(root_anim_node); + } + Iterator mesh_Iterator = meshes.iterator(); + while(mesh_Iterator.hasNext()){ + Mesh currentMesh = mesh_Iterator.next(); + currentMesh.draw(); + } + } + + + public void playAnimation(String s){ + this.currentAnimation = null; + Iterator animationIterator = animations.iterator(); + while(animationIterator.hasNext()){ + Animation current_iterator_item = animationIterator.next(); + if(current_iterator_item.name.equals(s)){ + this.currentAnimation = current_iterator_item; + } + } + if(currentAnimation != null){ + currentAnimation.timeCurrent = 0; + Iterator channelIterator = currentAnimation.channels.iterator(); + while(channelIterator.hasNext()){ + AnimChannel currentChannel = channelIterator.next(); + currentChannel.rewind(); + } + } + } + + public void incrementTime(double time){ + boolean isDone = currentAnimation.incrementTime(time); + if(isDone){ + currentAnimation.timeCurrent = 0; + Iterator channelIterator = currentAnimation.channels.iterator(); + while(channelIterator.hasNext()){ + AnimChannel currentChannel = channelIterator.next(); + currentChannel.rewind(); + } + Iterator boneIterator = bones.iterator(); + while(boneIterator.hasNext()){ + Bone currentBone = boneIterator.next(); + currentBone.transform = new Matrix4f(); + } + currentAnimation = null; + } else { + //First we push transformFromParent into deform so that later in the pipeline bones without a current animation take on transformFromParent as their transformation to the hierarchy + //I BELIEVE this is so that control bones still apply their offset to the hierarchy even when they're not animated :tm: + //4/5/20 + Iterator boneIterator = bones.iterator(); + while(boneIterator.hasNext()){ + Bone currentBone = boneIterator.next(); +// currentBone.deform = currentBone.transformFromParent; + } + //Once that's done, for every channel we set the corresponding bone's deform to the channels TRS + Iterator channelIterator = currentAnimation.channels.iterator(); + while(channelIterator.hasNext()){ + AnimChannel currentChannel = channelIterator.next(); + currentChannel.incrementTime(time); + Bone currentBone = boneMap.get(currentChannel.nodeID); + if(currentBone != null){ + //T * S * R + currentBone.deform = new Matrix4f(); + currentBone.deform.translate(currentChannel.getCurrentPosition()); + currentBone.deform.rotate(currentChannel.getCurrentRotation()); + currentBone.deform.scale(currentChannel.getCurrentScale()); + } + } + } + } + + public void describeAllAnimations(){ + if(animations.size() > 0){ + System.out.println("====================="); + System.out.println(animations.size() + " animations available in model!"); + Iterator animIterator = animations.iterator(); + while(animIterator.hasNext()){ + Animation currentAnim = animIterator.next(); + currentAnim.describeAnimation(); + } + } + } + + public final AnimNode build_anim_node_map(AINode node, AnimNode parent){ + AnimNode node_object = new AnimNode(node.mName().dataString(), parent, node); + node_map.put(node_object.id, node_object); + if(boneMap.containsKey(node_object.id)){ + node_object.is_bone = true; + } + int num_children = node.mNumChildren(); + for(int i = 0; i < num_children; i++){ + AnimNode temp_child = build_anim_node_map(AINode.create(node.mChildren().get(i)),node_object); +// if(boneMap.containsKey(node_object.id)){ +// Bone parent_bone = boneMap.get(node_object.id); +// node_object.children.add(temp_child); +// if(boneMap.containsKey(temp_child.id)){ +// Bone child_bone = boneMap.get(temp_child.id); +// parent_bone.children.add(child_bone); +// child_bone.parent = parent_bone; +// } +// } + node_object.children.add(temp_child); + } + return node_object; + } + + public void update_node_transform(AnimNode n){ + if(n.parent != null){ + n.transform = new Matrix4f(n.parent.transform); + } else { + n.transform = new Matrix4f(); + } + if(n.is_bone){ + /* + Bone bone = boneList.get(j); + Node node = rootNode.findByName(bone.getBoneName()); + Matrix4f boneMatrix = Node.getParentTransforms(node, i); + boneMatrix.mul(bone.getOffsetMatrix()); + boneMatrix = new Matrix4f(rootTransformation).mul(boneMatrix); + frame.setMatrix(j, boneMatrix); + */ + Bone target_bone = boneMap.get(n.id); + n.transform = n.transform.mul(target_bone.deform); + Matrix4f bone_matrix = new Matrix4f(n.transform).mul(target_bone.inverseBindPoseMatrix); + bone_matrix = new Matrix4f(globalInverseTransform).mul(bone_matrix); + target_bone.final_transform = bone_matrix; +// if(!toggled){ +// System.out.println(n.id); +// System.out.println("Transform:"); +// System.out.println(n.parent.transform); +// System.out.println(target_bone.deform); +// System.out.println(n.transform); +// System.out.println("Final transform:"); +// System.out.println(globalInverseTransform); +// System.out.println(n.transform); +// System.out.println(target_bone.inverseBindPoseMatrix); +// System.out.println(target_bone.final_transform); +// System.out.println("\n\n\n\n"); +// } + } else { + n.transform = n.transform.mul(util.util.convertAIMatrix(n.raw_data.mTransformation())); + } + Iterator node_iterator = n.children.iterator(); + while(node_iterator.hasNext()){ + AnimNode current_node = node_iterator.next(); + update_node_transform(current_node); + } + } +} diff --git a/src/main/java/RendererObjects/RenderUtils.java b/src/main/java/RendererObjects/RenderUtils.java new file mode 100644 index 00000000..22300950 --- /dev/null +++ b/src/main/java/RendererObjects/RenderUtils.java @@ -0,0 +1,279 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects; + +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.Iterator; +import main.Globals; +import org.joml.Matrix4f; +import org.joml.Vector3f; +import org.lwjgl.BufferUtils; +import org.lwjgl.opengl.GL11; +import static org.lwjgl.opengl.GL11.GL_FLOAT; +import static org.lwjgl.opengl.GL11.GL_INT; +import static org.lwjgl.opengl.GL11.GL_LEQUAL; +import static org.lwjgl.opengl.GL11.GL_LESS; +import static org.lwjgl.opengl.GL11.GL_SHORT; +import static org.lwjgl.opengl.GL11.GL_TRIANGLES; +import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT; +import org.lwjgl.opengl.GL15; +import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER; +import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW; +import static org.lwjgl.opengl.GL15.glBindBuffer; +import static org.lwjgl.opengl.GL15.glGenBuffers; +import org.lwjgl.opengl.GL20; +import static org.lwjgl.opengl.GL20.glEnableVertexAttribArray; +import static org.lwjgl.opengl.GL20.glGetUniformLocation; +import static org.lwjgl.opengl.GL20.glUniform1fv; +import static org.lwjgl.opengl.GL20.glUniform1i; +import static org.lwjgl.opengl.GL20.glUniform3fv; +import static org.lwjgl.opengl.GL20.glUniformMatrix4fv; +import static org.lwjgl.opengl.GL20.glUseProgram; +import static org.lwjgl.opengl.GL20.glVertexAttribPointer; +import static org.lwjgl.opengl.GL30.glBindVertexArray; +import static org.lwjgl.opengl.GL30.glGenVertexArrays; + +/** + * + * @author amaterasu + */ +public class RenderUtils { + public static Model createSkyboxModel(Material optionalMaterial){ + Model skybox_model = new Model(); + skybox_model.meshes = new ArrayList(); + + skybox_model.modelMatrix = new Matrix4f(); + + + + boolean apply_lighting = false; + boolean has_bones = false; + + Mesh skyboxmesh = new Mesh(){ + @Override + public void draw(){ + GL11.glDepthFunc(GL_LEQUAL); + glUseProgram(shader.shaderProgram); + + if(material == null){ + Globals.material_default.apply_material(0,1); + Iterator colorIterator = Globals.skybox_colors.iterator(); + int counter = 0; + float[] temp = new float[3]; + while(colorIterator.hasNext()){ + Vector3f colorCurrent = colorIterator.next(); + temp[0] = colorCurrent.x / 255.0f; + temp[1] = colorCurrent.y / 255.0f; + temp[2] = colorCurrent.z / 255.0f; +// System.out.println("colors[" + counter + "] " + temp[0] + " " + temp[1] + " " + temp[2]); + glUniform3fv(glGetUniformLocation(shader.shaderProgram, "colors[" + counter + "]"), temp); + counter++; + } + } + + glBindVertexArray(vertexArrayObject); + + + + + //buffer model/view/proj matrices + glUniformMatrix4fv(shader.shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16])); + glUniformMatrix4fv(shader.shaderVertexViewLoc, false, new Matrix4f(Globals.viewMatrix).scale(100).get(new float[16])); + glUniformMatrix4fv(shader.shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16])); + glUniform3fv(shader.shaderVertexViewPosLoc, Globals.camera_visible.pos_Center.get(BufferUtils.createFloatBuffer(3))); + + + GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + GL11.glDepthFunc(GL_LESS); + } + }; + + + skyboxmesh.mesh = null; + + // + // VAO + // + skyboxmesh.vertexArrayObject = glGenVertexArrays(); + glBindVertexArray(skyboxmesh.vertexArrayObject); + + + + + + + + + + + float[] vertexcoords = { + 1.0f,1.0f,1.0f, + 1.0f,1.0f,-1.0f, + 1.0f,-1.0f,1.0f, + 1.0f,-1.0f,-1.0f, + -1.0f,1.0f,1.0f, + -1.0f,1.0f,-1.0f, + -1.0f,-1.0f,1.0f, + -1.0f,-1.0f,-1.0f, + + }; + + // + //Buffer data to GPU + // + + try { + skyboxmesh.vertexCount = vertexcoords.length / 3; + FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount * 3); + float[] temp = new float[3]; + for (int i = 0; i < skyboxmesh.vertexCount; i++) { + temp[0] = vertexcoords[i * 3 + 0]; + temp[1] = vertexcoords[i * 3 + 1]; + temp[2] = vertexcoords[i * 3 + 2]; + VertexArrayBufferData.put(temp); + } + VertexArrayBufferData.flip(); + skyboxmesh.buffer_vertices(VertexArrayBufferData); + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + + int[] facedata = { + 0,1,4, + 1,4,5, + 1,3,5, + 3,5,7, + 4,5,7, + 4,6,7, + + 0,2,4, + 2,4,6, + 0,1,2, + 1,2,3, + + 2,3,6, + 3,6,7, + + }; + + // + // FACES + // + skyboxmesh.faceCount = facedata.length / 3; + skyboxmesh.elementCount = facedata.length; + IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(skyboxmesh.elementCount); + for(int i = 0; i < skyboxmesh.faceCount; i++){ + int[] temp = new int[3]; + temp[0] = facedata[i * 3 + 0]; + temp[1] = facedata[i * 3 + 1]; + temp[2] = facedata[i * 3 + 2]; + elementArrayBufferData.put(temp); + } + elementArrayBufferData.flip(); + skyboxmesh.buffer_faces(elementArrayBufferData); + + + + + if(optionalMaterial != null){ + // + // NORMALS + // + try { + skyboxmesh.normalCount = vertexcoords.length / 3; + FloatBuffer NormalArrayBufferData; + if(skyboxmesh.normalCount > 0){ + NormalArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.normalCount * 3); + float[] temp = new float[3]; + for (int i = 0; i < skyboxmesh.normalCount; i++) { + temp[0] = vertexcoords[i * 3 + 0]; + temp[1] = vertexcoords[i * 3 + 1]; + temp[2] = vertexcoords[i * 3 + 2]; + NormalArrayBufferData.put(temp); + } + NormalArrayBufferData.flip(); + skyboxmesh.buffer_normals(NormalArrayBufferData); + } + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + // + // TEXTURE COORDINATES + // + /*try { + skyboxmesh.textureCoordCount = mesh.mTextureCoords(0).capacity(); + FloatBuffer TextureArrayBufferData; + if(skyboxmesh.textureCoordCount > 0){ + TextureArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.textureCoordCount * 2); + float[] temp = new float[2]; + for (int i = 0; i < skyboxmesh.textureCoordCount; i++) { + AIVector3D normal = texturecoords.get(i); + temp[0] = normal.x(); + temp[1] = normal.y(); + // temp[2] = normal.z(); + TextureArrayBufferData.put(temp); + } + TextureArrayBufferData.flip(); + skyboxmesh.buffer_texture_coords(TextureArrayBufferData); + } + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + + skyboxmesh.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting); + + skybox_model.materials.add(optionalMaterial); + */ + } else { + skyboxmesh.shader = ShaderProgram.loadSpecificShader("/Shaders/skybox/VertexShaderNoTexture.vs", "/Shaders/skybox/FragmentShaderNoTexture.fs"); + try { + FloatBuffer ColorArrayBufferData = BufferUtils.createFloatBuffer(skyboxmesh.vertexCount); + for (int i = 0; i < skyboxmesh.vertexCount; i++) { + ColorArrayBufferData.put(i); + } + ColorArrayBufferData.flip(); + int idBuffer = glGenBuffers(); + glBindBuffer(GL_ARRAY_BUFFER, idBuffer); + GL15.glBufferData(GL_ARRAY_BUFFER, ColorArrayBufferData, GL_STATIC_DRAW); + glVertexAttribPointer(1, 1, GL11.GL_FLOAT, false, 0, 0); + glEnableVertexAttribArray(1); + } catch (NullPointerException ex){ + ex.printStackTrace(); + } + } + + + + + skyboxmesh.hasBones = false; + + + + + glBindVertexArray(0); + + + + + + + + + + skyboxmesh.nodeID = "skybox"; + + skyboxmesh.parent = skybox_model; + + + skybox_model.meshes.add(skyboxmesh); + + + return skybox_model; + } +} diff --git a/src/main/java/RendererObjects/ShaderProgram.java b/src/main/java/RendererObjects/ShaderProgram.java new file mode 100644 index 00000000..fa73c977 --- /dev/null +++ b/src/main/java/RendererObjects/ShaderProgram.java @@ -0,0 +1,374 @@ +package RendererObjects; + +import main.Main; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import org.lwjgl.opengl.GL20; +import static org.lwjgl.opengl.GL20.*; + +/** + * + * @author amaterasu + */ +public class ShaderProgram { + // + //Program stuff + // + int vertexShader; + int fragmentShader; + int shaderProgram; + + + // + //Uniform locations + // + public int shaderVertexModelLoc; + public int shaderVertexViewLoc; + public int shaderVertexProjectionLoc; + public int shaderVertexViewPosLoc; + public int shaderVertexBonesLoc; + public int shaderVertexHasBonesLoc; + public int shaderVertexNumBonesLoc; + + + //Uniforms + //list of names of all uniforms in the shader + public ArrayList uniformList; + //map + //string -> tuple + //tuple: a string describing the type of the data,the current value,location + //ie arrayVec3,[<1,0,0>,<2,0,0>],colors + // Mat4,[Matrix4f],modelMatrix + public HashMap uniformMap; + + public static ShaderProgram smart_assemble_shader(boolean ContainsBones, boolean apply_lighting){ + + String vertex_shader_path = ""; + if(ContainsBones){ + vertex_shader_path = "/Shaders/VertexShader.vs"; + } else { + vertex_shader_path = "/Shaders/VertexShaderNoBones.vs"; + } + + String fragment_shader_path = "/Shaders/FragmentShader.fs"; + // + //Create ShaderProgram object + // + ShaderProgram rVal = new ShaderProgram(); + // + //Read in shader programs + // + String tempForReadingShaders = ""; + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource(vertex_shader_path).getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String vertexShaderSource = tempForReadingShaders; + //This try-catch block reads the FragmentShader source into memory + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource(fragment_shader_path).getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String fragmentShaderSource = tempForReadingShaders; + //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" + rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); + //This alerts openGL to the presence of a vertex shader and points the shader at its source + glShaderSource(rVal.vertexShader, vertexShaderSource); + //Compiles the source for the vertex shader object + glCompileShader(rVal.vertexShader); + //The following tests if the vertex shader compiles successfully + int success; + success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Vertex Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)); + } + //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader + rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + //This points the opengl shadder object to its proper source + glShaderSource(rVal.fragmentShader, fragmentShaderSource); + //This compiles the shader object + glCompileShader(rVal.fragmentShader); + //This tests for the success of the compile attempt + success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Fragment Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)); + } + //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram + rVal.shaderProgram = glCreateProgram(); + //This attaches the vertex and fragment shaders to the program + glAttachShader(rVal.shaderProgram, rVal.vertexShader); + glAttachShader(rVal.shaderProgram, rVal.fragmentShader); + //This links the program to the GPU (I think its to the GPU anyway) + glLinkProgram(rVal.shaderProgram); + //Tests for the success of the shader program creation + success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS); + if (success != GL_TRUE) { + throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram)); + } + + //Deletes the individual shader objects to free up memory + glDeleteShader(rVal.vertexShader); + glDeleteShader(rVal.fragmentShader); + + + + // + //Set locations + // + rVal.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderProgram, "model"); + rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderProgram, "view"); + rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderProgram, "projection"); + rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderProgram, "viewPos"); + if(ContainsBones){ + rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderProgram, "bones"); + rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderProgram, "numBones"); + } + rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderProgram, "hasBones"); + + + + + return rVal; + } + public static ShaderProgram load_default_shader_program(){ + + + // + //Create ShaderProgram object + // + ShaderProgram rVal = new ShaderProgram(); + // + //Read in shader programs + // + String tempForReadingShaders = ""; + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource("/Shaders/VertexShader.vs").getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String vertexShaderSource = tempForReadingShaders; + //This try-catch block reads the FragmentShader source into memory + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource("/Shaders/FragmentShader.fs").getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String fragmentShaderSource = tempForReadingShaders; + //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" + rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); + //This alerts openGL to the presence of a vertex shader and points the shader at its source + glShaderSource(rVal.vertexShader, vertexShaderSource); + //Compiles the source for the vertex shader object + glCompileShader(rVal.vertexShader); + //The following tests if the vertex shader compiles successfully + int success; + success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Vertex Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)); + } + //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader + rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + //This points the opengl shadder object to its proper source + glShaderSource(rVal.fragmentShader, fragmentShaderSource); + //This compiles the shader object + glCompileShader(rVal.fragmentShader); + //This tests for the success of the compile attempt + success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Fragment Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)); + } + //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram + rVal.shaderProgram = glCreateProgram(); + //This attaches the vertex and fragment shaders to the program + glAttachShader(rVal.shaderProgram, rVal.vertexShader); + glAttachShader(rVal.shaderProgram, rVal.fragmentShader); + //This links the program to the GPU (I think its to the GPU anyway) + glLinkProgram(rVal.shaderProgram); + //Tests for the success of the shader program creation + success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS); + if (success != GL_TRUE) { + throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram)); + } + + //Deletes the individual shader objects to free up memory + glDeleteShader(rVal.vertexShader); + glDeleteShader(rVal.fragmentShader); + + + + // + //Set locations + // + rVal.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderProgram, "model"); + rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderProgram, "view"); + rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderProgram, "projection"); + rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderProgram, "viewPos"); + rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderProgram, "bones"); + rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderProgram, "numBones"); + rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderProgram, "hasBones"); + + + + + return rVal; + } + + public static ShaderProgram loadSpecificShader(String vertexPath, String fragmentPath){ + ShaderProgram rVal = new ShaderProgram(); + + String vertex_shader_path = vertexPath; + String fragment_shader_path = fragmentPath; + // + //Read in shader programs + // + String tempForReadingShaders = ""; + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource(vertex_shader_path).getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String vertexShaderSource = tempForReadingShaders; + //This try-catch block reads the FragmentShader source into memory + try { + BufferedReader br = new BufferedReader(new FileReader(Main.class.getResource(fragment_shader_path).getFile())); + try { + StringBuilder sb = new StringBuilder(); + String line = br.readLine(); + while (line != null) { + sb.append(line); + sb.append(System.lineSeparator()); + line = br.readLine(); + } + tempForReadingShaders = sb.toString(); + } finally { + br.close(); + } + } catch (IOException e) { + } + String fragmentShaderSource = tempForReadingShaders; + //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" + rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); + //This alerts openGL to the presence of a vertex shader and points the shader at its source + glShaderSource(rVal.vertexShader, vertexShaderSource); + //Compiles the source for the vertex shader object + glCompileShader(rVal.vertexShader); + //The following tests if the vertex shader compiles successfully + int success; + success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Vertex Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)); + } + //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader + rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + //This points the opengl shadder object to its proper source + glShaderSource(rVal.fragmentShader, fragmentShaderSource); + //This compiles the shader object + glCompileShader(rVal.fragmentShader); + //This tests for the success of the compile attempt + success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); + if (success != GL_TRUE) { + System.out.println("Fragment Shader failed to compile!"); + throw new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)); + } + //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram + rVal.shaderProgram = glCreateProgram(); + //This attaches the vertex and fragment shaders to the program + glAttachShader(rVal.shaderProgram, rVal.vertexShader); + glAttachShader(rVal.shaderProgram, rVal.fragmentShader); + //This links the program to the GPU (I think its to the GPU anyway) + glLinkProgram(rVal.shaderProgram); + //Tests for the success of the shader program creation + success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS); + if (success != GL_TRUE) { + throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram)); + } + + //Deletes the individual shader objects to free up memory + glDeleteShader(rVal.vertexShader); + glDeleteShader(rVal.fragmentShader); + + + + // + //Set locations + // + rVal.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderProgram, "model"); + rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderProgram, "view"); + rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderProgram, "projection"); + rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderProgram, "viewPos"); + + + + + return rVal; + } + +} diff --git a/src/main/java/RendererObjects/texture/Texture.java b/src/main/java/RendererObjects/texture/Texture.java new file mode 100644 index 00000000..75001661 --- /dev/null +++ b/src/main/java/RendererObjects/texture/Texture.java @@ -0,0 +1,136 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package RendererObjects.texture; + +import java.awt.Color; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.imageio.ImageIO; +import org.lwjgl.BufferUtils; +import static org.lwjgl.opengl.GL11.*; +import static org.lwjgl.opengl.GL14.*; +import static org.lwjgl.opengl.GL30.*; + +/** + * + * @author amaterasu + */ +public class Texture { + int texture_pointer; + int width; + int height; + boolean hasTransparency; + public Texture(){ + + } + public Texture(String path){ + //generate the texture object on gpu + texture_pointer = glGenTextures(); + //bind the new texture + glBindTexture(GL_TEXTURE_2D, texture_pointer); + //how are we gonna wrap the texture?? + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); + //set the border color to black + float borderColor[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); + //set magnification and minification operation sampling strategies + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + //load the image here + ByteBuffer data; + width = 1; + height = 1; + try { + BufferedImage image_data = ImageIO.read(new File(Thread.currentThread().getContextClassLoader().getResource(path).getFile())); + if ( + image_data.getType() == BufferedImage.TYPE_3BYTE_BGR || + image_data.getType() == BufferedImage.TYPE_INT_RGB + ){ + hasTransparency = false; + } else if( + image_data.getType() == BufferedImage.TYPE_4BYTE_ABGR || + image_data.getType() == BufferedImage.TYPE_INT_ARGB + ){ + hasTransparency = true; + } + width = image_data.getWidth(); + height = image_data.getHeight(); + if(hasTransparency){ + data = BufferUtils.createByteBuffer(width * height * 4); + } else { + data = BufferUtils.createByteBuffer(width * height * 3); + } + /* + imgBuffer = BufferUtils.createByteBuffer(4 * dimX * dimY); + for(int x = 0; x < dimX; x++){ + for(int y = 0; y < dimY; y++){ + Color temp = new Color(image_data.getRGB(x, y)); + data.put((byte)(temp.getRed()); + data.put((byte)(temp.getGreen()); + data.put((byte)(temp.getBlue()); + data.put((byte)(temp.getAlpha()); + } + } + imgBuffer.flip(); + */ + for(int y = height - 1; y > -1; y--){ + for(int x = 0; x < width; x++){ + Color temp = new Color(image_data.getRGB(x, y), true); + + data.put((byte)temp.getRed()); + data.put((byte)temp.getGreen()); + data.put((byte)temp.getBlue()); + if(hasTransparency){ + data.put((byte)temp.getAlpha()); + } +// data[x * y * 3 + 0] = temp.getRed(); +// data[x * y * 3 + 1] = temp.getGreen(); +// data[x * y * 3 + 2] = temp.getBlue(); + } + } + } catch (IOException ex) { + ex.printStackTrace(); + hasTransparency = false; + data = BufferUtils.createByteBuffer(3); + data.put((byte)0); + data.put((byte)0); + data.put((byte)0); + } + data.flip(); + //call if width != height so opengl figures out how to unpack it properly + if(width != height){ + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + } + //buffer the texture information + if(hasTransparency){ + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); + } else { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); + } + glGenerateMipmap(GL_TEXTURE_2D); + //OPTIONAL free the original image data now that it's on the gpu + System.gc(); + } + + public void bind(){ + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture_pointer); + } + + public void bind(int attrib_val){ + glActiveTexture(GL_TEXTURE0 + attrib_val); + glBindTexture(GL_TEXTURE_2D, texture_pointer); + } + + public boolean isTransparent(){ + return hasTransparency; + } +} diff --git a/src/main/java/RendererObjects/texture/TextureMap.java b/src/main/java/RendererObjects/texture/TextureMap.java new file mode 100644 index 00000000..d0c87c9f --- /dev/null +++ b/src/main/java/RendererObjects/texture/TextureMap.java @@ -0,0 +1,64 @@ +package RendererObjects.texture; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +/** + * + * @author amaterasu + */ +public class TextureMap { + //The convention is + //Map of strings (the name of a model) to a model + //each model is a map of a string (the name of a mesh) to a list which contains + //First the model's diffuse, then the model's specular + //always in that order + //if either the diffuse or the specular isn't included then it should + //instead contain and empty string - "" + //this convention must be followed + Map>> texture_map = new HashMap(); + + public Map> get_mesh_map(String name){ + return texture_map.get(name); + } + + public static ArrayList get_mesh_textures(Map> input, String name){ + if(input == null){ + //TODO: Add big fuckin' error here + return null; + } + return input.get(name); + } + + //for the lazy + public static String get_diffuse_path(ArrayList input){ + if(input == null || input.size() < 2){ + //TODO: Add big fuckin' error here + return null; + } + return input.get(0); + } + + //for the lazy + public static String get_specular_path(ArrayList input){ + if(input == null || input.size() < 2){ + //TODO: Add big fuckin' error here + return null; + } + return input.get(1); + } + + public TextureMap(){ + texture_map = new HashMap(); + } + public void add_model(String model_name){ + texture_map.put(model_name, new HashMap()); + } + public void add_mesh_to_model(String model_name, String mesh_name){ + ArrayList temp = new ArrayList(); + temp.add(""); + temp.add(""); + texture_map.get(model_name).put(mesh_name, temp); + } +} diff --git a/src/main/java/audio/AudioEngine.java b/src/main/java/audio/AudioEngine.java new file mode 100644 index 00000000..7fff6414 --- /dev/null +++ b/src/main/java/audio/AudioEngine.java @@ -0,0 +1,14 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package audio; + +/** + * + * @author amaterasu + */ +public class AudioEngine { + +} diff --git a/src/main/java/entity/Entity.java b/src/main/java/entity/Entity.java new file mode 100644 index 00000000..1d0ba15f --- /dev/null +++ b/src/main/java/entity/Entity.java @@ -0,0 +1,37 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package entity; + +import java.util.HashMap; + +/** + * + * @author amaterasu + */ +public class Entity { + + static int entity_id_iterator = 0; + + int id; + + HashMap data; + + + + public int getId() { + return id; + } + + public HashMap getData() { + return data; + } + + public Entity(){ + data = new HashMap(); + id = entity_id_iterator; + entity_id_iterator++; + } +} diff --git a/src/main/java/entity/EntityUtil.java b/src/main/java/entity/EntityUtil.java new file mode 100644 index 00000000..0276c50f --- /dev/null +++ b/src/main/java/entity/EntityUtil.java @@ -0,0 +1,45 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package entity; + +import RendererObjects.Model; +import main.Globals; +import org.joml.Quaternionf; +import org.joml.Vector3f; + +/** + * + * @author amaterasu + */ +public class EntityUtil { + + public static Vector3f getEntityPosition(Entity e){ + return (Vector3f)e.getData().get("position"); + } + + public static Quaternionf getEntityRotation(Entity e){ + return (Quaternionf)e.getData().get("rotation"); + } + + public static Vector3f getEntityScale(Entity e){ + return (Vector3f)e.getData().get("scale"); + } + + public static Model getEntityModel(Entity e){ + return (Model)e.getData().get("model"); + } + + public static Entity spawnDrawableEntity(Model m){ + Entity rVal = new Entity(); + rVal.getData().put("model", m); + rVal.getData().put("position", new Vector3f(0,0,0)); + rVal.getData().put("rotation", new Quaternionf().rotateAxis((float)0, new Vector3f(1,0,0))); + rVal.getData().put("scale", new Vector3f(1,1,1)); + Globals.entity_list.add(rVal); + Globals.drawable_list.add(rVal); + return rVal; + } +} diff --git a/src/main/java/main/Globals.java b/src/main/java/main/Globals.java new file mode 100644 index 00000000..1bb106d9 --- /dev/null +++ b/src/main/java/main/Globals.java @@ -0,0 +1,93 @@ +package main; + +import RendererObjects.Camera; +import RendererObjects.Light.DirectionalLight; +import RendererObjects.Light.PointLight; +import RendererObjects.Light.SpotLight; +import RendererObjects.Material; +import RendererObjects.Model; +import RendererObjects.texture.Texture; +import RendererObjects.texture.TextureMap; +import com.google.gson.Gson; +import entity.Entity; +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.joml.Matrix4f; +import org.joml.Vector3f; +import util.ModelLoader; + +/** + * + * @author amaterasu + */ +public class Globals { + + // + //OpenGL - Other + // + //Array that holds all models that need to be shoved to the gpu + public static Matrix4f viewMatrix = new Matrix4f(); + public static Matrix4f projectionMatrix; + + + + public static Texture texture_diffuse_default; + public static Texture texture_specular_default; + public static Material material_default; + + public static DirectionalLight light_directional_default; + public static ArrayList light_point_list_default; + public static SpotLight light_spot_default; + + public static TextureMap texture_map_default; + + public static ArrayList entity_list; + public static ArrayList drawable_list; + + public static Camera camera_visible; + + // + //Game specific models + // + + //famous fuckin last words, but temporary solution + //global arraylist of values for the skybox colors + public static ArrayList skybox_colors; + + + + public static void init_globals(){ + //create default textures + texture_diffuse_default = new Texture("Textures/default_diffuse.png"); + texture_specular_default = new Texture("Textures/default_specular.png"); + //create default material + material_default = new Material(); + material_default.set_diffuse(texture_diffuse_default); + material_default.set_specular(texture_specular_default); + //create default lights + light_directional_default = new DirectionalLight(new Vector3f(0,-1f,0)); + //load in default texture map + Gson gson = new Gson(); + try { + //deserializes the texture map from its default path using gson + //also done in one line + texture_map_default = gson.fromJson(Files.newBufferedReader(new File(Thread.currentThread().getContextClassLoader().getResource("Textures/default_texture_map.json").getFile()).toPath()), TextureMap.class); //only the best of coding practices :) + } catch (IOException ex) { ex.printStackTrace(); } //TODO: handle better :tm: + //create entity list + entity_list = new ArrayList(); + drawable_list = new ArrayList(); + //create the camera object that generates view matrix + camera_visible = new Camera(); + //init game specific variables + init_game_specifics(); + //temporary hold for skybox colors + skybox_colors = new ArrayList(); + } + + public static void init_game_specifics(){ + } +} diff --git a/src/main/java/main/Main.java b/src/main/java/main/Main.java new file mode 100644 index 00000000..c2b27685 --- /dev/null +++ b/src/main/java/main/Main.java @@ -0,0 +1,564 @@ +package main; + +import RendererObjects.Camera; +import RendererObjects.Material; +import RendererObjects.Model; +import RendererObjects.RenderUtils; +import RendererObjects.ShaderProgram; +import RendererObjects.texture.Texture; +import entity.Entity; +import entity.EntityUtil; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Random; +import java.util.concurrent.TimeUnit; +import org.joml.Matrix4f; +import org.joml.Quaternionf; +import org.joml.Vector3f; +import org.lwjgl.glfw.*; +import static org.lwjgl.glfw.GLFW.*; +import org.lwjgl.opengl.*; +import static org.lwjgl.opengl.GL11.*; +import static org.lwjgl.opengl.GL13.*; +import static org.lwjgl.opengl.GL14.*; +import static org.lwjgl.opengl.GL15.*; +import static org.lwjgl.opengl.GL20.*; +import static org.lwjgl.opengl.GL30.*; +import static org.lwjgl.system.MemoryUtil.NULL; +import util.ModelLoader; +import util.util; + + +/** + * + * @author amaterasu + */ +public class Main { + // + //Generic OpenGL Statements + // + //Callback function for opengl errors + private final static GLFWErrorCallback ERROR_CALLBACK = GLFWErrorCallback.createPrint(System.err); + private static long window; + + + + + + + + // + //Visualization Controls + // + //These are used in calculating the time between frames for visualization (camera) control and such + public static float deltaTime = 0.0f; + public static float lastFrame = 0.0f; + //View Controls + public static float view_Range = 2000.0f; + public static Camera camera_Current = new Camera(); + /* + Mouse Controls + */ + static float mouse_lastX = 400; + static float mouse_lastY = 300; + static double xpos = 400; + static double ypos = 300; + static float mouseSensitivity = .1f; + static double mouse_X_Buffer[] = new double[1]; + static double mouse_Y_Buffer[] = new double[1]; + static float cameraSpeed; + static float yaw = 150; + static float pitch = 50; + + + + // + //Player Object Variables + // + public static boolean CAMERA_UNDER_USER_CONTROL = false; + public static boolean CAMERA_UNDER_FREE_CONTROL = false; + public static boolean PLAYER_UNDER_USER_CONTROL = true; + public static boolean CAMERA_IS_ORBIT = true; + public static float camera_Orbit_Length = 1.0f; +// public static Camera cam_Player_Orbit; + //Camera angles using theta-phi system + //Euler angles where theta is applied, then phi + //There is no bank applied to the camera + + public static Model model; + + + + + public static void main(String args[]){ + + // + // + // I N I T I A L I Z A T I O N + // + // + + //run initialization stuff + + //Create opengl + create_opengl_context(); + + //init global variables + Globals.init_globals(); + + + + + initWorld(); + + init_skybox(); + + + + Entity player = new Entity(); + player.getData().put("position", new Vector3f(0f,6f,0f)); + + + + + + /// + /// C A M E R A C R E A T I O N + /// + Camera camera_player_chase = new Camera(); + Camera cam_Player_Orbit = new Camera(); + + + + //main loop + while (!glfwWindowShouldClose(window)) { + + /* + Frame calculation + */ + float currentFrame = (float) glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + + //poll mouse variables and update camera variables + update_mouse_variables(); + + + float cam_Player_Orbit_Magnitude = 1f; + float cam_Player_Orbit_Offset_Height = 1f; + cam_Player_Orbit.pos_Center = new Vector3f(0, 0, 0); + cam_Player_Orbit.pos_Center.x = 0 + (float) Math.cos(yaw / 180.0f * Math.PI) * cam_Player_Orbit_Magnitude; + cam_Player_Orbit.pos_Center.y = 0 + (float) Math.sin(pitch / 180.0f * Math.PI) * cam_Player_Orbit_Magnitude; + cam_Player_Orbit.pos_Center.z = 0 + (float) Math.sin(yaw / 180.0f * Math.PI) * cam_Player_Orbit_Magnitude; + cam_Player_Orbit.pos_Center.normalize(); +// System.out.println(cam_Player_Orbit.pos_Center); + + + + if(CAMERA_IS_ORBIT){ + camera_Current = cam_Player_Orbit; + } + + + + + /// + /// I N P U T C O N T R O L S + /// + cameraSpeed = 2.5f * deltaTime; + if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + break; + } + if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) { + if(CAMERA_UNDER_FREE_CONTROL) { + //cameraSpeed = cameraSpeed * 100; + } else if(PLAYER_UNDER_USER_CONTROL) { + + } + } + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(-camera_Current.pos_Center.x,0,-camera_Current.pos_Center.z)); + } + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(camera_Current.pos_Center.x,0,camera_Current.pos_Center.z)); + } + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(-camera_Current.pos_Center.x,0,-camera_Current.pos_Center.z).rotateY((float)(-90 * Math.PI / 180))); + } + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(-camera_Current.pos_Center.x,0,-camera_Current.pos_Center.z).rotateY((float)(90 * Math.PI / 180))); + } + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(0,0.6f,0)); + } + if(glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS){ + EntityUtil.getEntityPosition(player).add(new Vector3f(0,-0.6f,0)); + } + + +// camera_player_chase.pos_Center = new Vector3f(EntityUtil.getEntityPosition(player)).sub(EntityUtil.getEntityRotation(player).transform(new Vector3f(-1,1,0))); + + Globals.camera_visible.apply_camera(camera_player_chase); + + Globals.viewMatrix = Globals.camera_visible.get_view_matrix(); + Globals.viewMatrix = new Matrix4f().setLookAt(camera_Current.pos_Center, new Vector3f(0,0,0), new Vector3f(camera_Current.pos_Center).add(new Vector3f(0,1.0f,0))).scale(1.0f, 1.5f, 1.0f); + + //Sets the background color. + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + + // + // Draw all entities + // + Iterator entity_iterator = Globals.drawable_list.iterator(); + while(entity_iterator.hasNext()){ + Entity currentEntity = entity_iterator.next(); + Model currentModel = EntityUtil.getEntityModel(currentEntity); + currentModel.modelMatrix = new Matrix4f(); + currentModel.modelMatrix.translate(new Vector3f(EntityUtil.getEntityPosition(currentEntity)).sub(EntityUtil.getEntityPosition(player))); + currentModel.modelMatrix.rotate(EntityUtil.getEntityRotation(currentEntity)); + currentModel.modelMatrix.scale(EntityUtil.getEntityScale(currentEntity)); + currentModel.draw(); + } + + + + //check and call events and swap the buffers + glfwSwapBuffers(window); + glfwPollEvents(); + } + //Terminate the program. + glfwTerminate(); + } + + static void sleep(int i) { + try { + TimeUnit.MILLISECONDS.sleep(i); + } catch (InterruptedException ex) { + System.out.println("Sleep somehow interrupted?!"); + } + } + + + + + + + + + + public static void create_opengl_context(){ + //Sets the variables that control the window sizing + int screenWidth = 1920; + int screenHeight = 1080; + //Initializes opengl + glfwInit(); + //Gives hints to glfw to control how opengl will be used + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + //Creates the window reference object + window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", NULL, NULL); + //Errors for failure to create window (IE: No GUI mode on linux ?) + if (window == NULL) { + System.out.println("Failed to make window."); + glfwTerminate(); + } + //Makes the window that was just created the current OS-level window context + glfwMakeContextCurrent(window); + //Maximize it + glfwMaximizeWindow(window); + //Creates the OpenGL capabilities for the program. + GL.createCapabilities(); + + //This enables Z-buffering so that farther-back polygons are not drawn over nearer ones + glEnable(GL_DEPTH_TEST); + + // Support for transparency + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + //Hide the cursor and capture it + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + + + + + + //Points the texture uniforms in the shader programs at the correct variables + + + + + // + // Projection and View matrix creation + // + Globals.projectionMatrix = new Matrix4f(); + Globals.viewMatrix = new Matrix4f(); + float FOV = (float)(120.0f * Math.PI /180.0f); + Globals.projectionMatrix.setPerspective(FOV, 1.0f, 0.1f, view_Range); + Globals.viewMatrix.translation(new Vector3f(0.0f,0.0f,-3.0f)); + } + + + public static void update_mouse_variables(){ + glfwGetCursorPos(window, mouse_X_Buffer, mouse_Y_Buffer); + xpos = mouse_X_Buffer[0]; + ypos = mouse_Y_Buffer[0]; + float xoffset = (float) (xpos - mouse_lastX) * mouseSensitivity; + float yoffset = (float) (mouse_lastY - ypos) * mouseSensitivity; + mouse_lastX = (float) xpos; + mouse_lastY = (float) ypos; + + yaw = yaw + xoffset; + pitch = pitch - yoffset; + + if (pitch > 100.0f) { + pitch = 100.0f; + } + if (pitch < -99.0f) { + pitch = -99.0f; + } + } + + static void init_skybox(){ + Model skyboxModel = RenderUtils.createSkyboxModel(null); + Entity skyboxEntity = EntityUtil.spawnDrawableEntity(skyboxModel); + EntityUtil.getEntityScale(skyboxEntity).mul(100); + + + Globals.skybox_colors.add(new Vector3f(200,200,160)); + Globals.skybox_colors.add(new Vector3f(200,200,160)); + Globals.skybox_colors.add(new Vector3f(200,100,50)); + Globals.skybox_colors.add(new Vector3f(200,100,50)); + Globals.skybox_colors.add(new Vector3f(50,100,150)); + Globals.skybox_colors.add(new Vector3f(50,100,150)); + Globals.skybox_colors.add(new Vector3f(10,10,10)); + Globals.skybox_colors.add(new Vector3f(10,10,10)); + } + + + //I swear it's a temporary function + /* + for(int angle = 0; angle < 45; angle=angle+2){ + for(int radius = 115; radius < 130; radius=radius+2){ + */ +// static float[] getTreePos(){ +// return new float[]{ +// 115.0f,7.0f,0.0f, +// 110.0f,7.0f,10.0f, +// +// 82.0f,7.0f,82.0f, +// }; +// } + + static void initWorld(){ + Model building_model = ModelLoader.load_Model_From_File("Models/arcdock5deg1Try2.fbx"); + Texture whiteTexture = new Texture("Textures/w1.png"); + Material whiteMaterial = new Material(); + whiteMaterial.set_diffuse(whiteTexture); + whiteMaterial.set_specular(whiteTexture); + building_model.meshes.get(0).set_material(whiteMaterial); + for(int i = 0; i < 36; i++){ + Entity arcCurrent = EntityUtil.spawnDrawableEntity(building_model); + float angleRad = i * 10; + float angleDeg = (float)(angleRad * Math.PI / 180); + float posX = (float)(Math.cos(angleDeg) * 100); + float posY = (float)(Math.sin(angleDeg) * 100); + EntityUtil.getEntityPosition(arcCurrent).set(posX, 0.01f, posY); + EntityUtil.getEntityScale(arcCurrent).set(1f); + EntityUtil.getEntityRotation(arcCurrent) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)((180-angleRad) * Math.PI / 180)) + ; + arcCurrent = EntityUtil.spawnDrawableEntity(building_model); + angleRad = i * 10 + 5; + angleDeg = (float)(angleRad * Math.PI / 180); + posX = (float)(Math.cos(angleDeg) * 100); + posY = (float)(Math.sin(angleDeg) * 100); + EntityUtil.getEntityPosition(arcCurrent).set(posX, 5.01f, posY); + EntityUtil.getEntityScale(arcCurrent).set(1f); + EntityUtil.getEntityRotation(arcCurrent) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)((180-angleRad) * Math.PI / 180)) + ; + } + + + Model dirtPlane = ModelLoader.load_Model_From_File("Models/groundplanemassiveuv.fbx"); + Texture dirtTexture = new Texture("Textures/Ground/Dirt1.png"); + Material dirtMaterial = new Material(); + dirtMaterial.set_diffuse(dirtTexture); + dirtMaterial.set_specular(dirtTexture); + dirtPlane.meshes.get(0).set_material(dirtMaterial); + for(int x = -120; x < 120; x=x+20){ + for(int y = -120; y < 120; y=y+20){ + Entity dirtPlaneEntity = EntityUtil.spawnDrawableEntity(dirtPlane); + EntityUtil.getEntityPosition(dirtPlaneEntity).set(x, -1.0f, y); + EntityUtil.getEntityScale(dirtPlaneEntity).set(10f); + EntityUtil.getEntityRotation(dirtPlaneEntity) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + ; + } + } + + Model tree2 = ModelLoader.load_Model_From_File("Models/tree2.fbx"); + Texture leavesTexture = new Texture("Textures/leaves.png"); + Material leavesMaterial = new Material(); + leavesMaterial.set_diffuse(leavesTexture); + leavesMaterial.set_specular(leavesTexture); + Texture trunkTexture = new Texture("Textures/trunk.png"); + Material trunkMaterial = new Material(); + trunkMaterial.set_diffuse(trunkTexture); + trunkMaterial.set_specular(trunkTexture); + tree2.meshes.get(0).set_material(trunkMaterial); + tree2.meshes.get(1).set_material(leavesMaterial); + tree2.meshes.get(2).set_material(leavesMaterial); + Random treeRand = new Random(); + + ArrayList treeList = new ArrayList(); + for(int angle = -105; angle < 45; angle=angle+2){ + for(int radius = 115; radius < 140; radius=radius+2){ + Entity treeEntity = EntityUtil.spawnDrawableEntity(tree2); + EntityUtil.getEntityPosition(treeEntity).set( + (float)Math.cos(angle * Math.PI / 180) * radius + (treeRand.nextFloat() - 0.5f) * 2, + radius - 113 + treeRand.nextFloat(), + (float)Math.sin(angle * Math.PI / 180) * radius + (treeRand.nextFloat() - 0.5f) * 2 + ); + EntityUtil.getEntityScale(treeEntity).set(1f); + EntityUtil.getEntityRotation(treeEntity) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)((treeRand.nextFloat() * 359) * Math.PI / 180)) + ; + treeList.add(treeEntity); + } + } +// float[] treepos = getTreePos(); +// for(int i = 0; i < treepos.length/3; i++){ +// float posX = treepos[i*3]; +// float posY = treepos[i*3+1]; +// float posZ = treepos[i*3+2]; +// Entity treeEntity = EntityUtil.spawnDrawableEntity(tree2); +// EntityUtil.getEntityPosition(treeEntity).set(posX,posY,posZ); +// EntityUtil.getEntityScale(treeEntity).set(1f); +// EntityUtil.getEntityRotation(treeEntity) +// .identity() +// .rotateLocalX((float)(-Math.PI / 2)) +// .rotateLocalY((float)((treeRand.nextFloat() * 359) * Math.PI / 180)) +// ; +// treeList.add(treeEntity); +// } + + Model arenaSpire = ModelLoader.load_Model_From_File("Models/ArenaSpire1.fbx"); + arenaSpire.meshes.get(0).set_material(whiteMaterial); + Entity spireEntity = EntityUtil.spawnDrawableEntity(arenaSpire); + EntityUtil.getEntityRotation(spireEntity) + .identity() + .rotateLocalZ((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(220) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(spireEntity).set(-105, 0, 0); + + Model railTrackModel = ModelLoader.load_Model_From_File("Models/RailTrack1Part1.fbx"); + Texture railTrackTexture = new Texture("Textures/RailTrack1Part1.png"); + Material railTrackMaterial = new Material(); + railTrackMaterial.set_diffuse(railTrackTexture); + railTrackMaterial.set_specular(railTrackTexture); + railTrackModel.meshes.get(0).set_material(railTrackMaterial); + Entity railTrackEntity = EntityUtil.spawnDrawableEntity(railTrackModel); + EntityUtil.getEntityRotation(railTrackEntity) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(0) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railTrackEntity).set(-15, 10, -20); + + Model railSupportModel = ModelLoader.load_Model_From_File("Models/MonorailSupport.fbx"); + Texture railSupportTexture = new Texture("Textures/MonorailSupport.png"); + Material railSupportMaterial = new Material(); + railSupportMaterial.set_diffuse(railSupportTexture); + railSupportMaterial.set_specular(railSupportTexture); + railSupportModel.meshes.get(0).set_material(railSupportMaterial); + + //support 1 + Entity railSupport1 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport1) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(180) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport1).set(0, -71.5f, -125); + + //support 2 + Entity railSupport2 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport2) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(200) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport2).set(30, -69.5f, -115); + + //support 3 + Entity railSupport3 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport3) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(217) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport3).set(62, -65.5f, -95); + + //support 4 + Entity railSupport4 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport4) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(222) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport4).set(90, -61f, -70); + + //support 5 + Entity railSupport5 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport5) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(235) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport5).set(121, -57.5f, -25); + + //support 6 + Entity railSupport6 = EntityUtil.spawnDrawableEntity(railSupportModel); + EntityUtil.getEntityRotation(railSupport6) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(265) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(railSupport6).set(135, -58.5f, 30); + + + Model tallBuildingModel = ModelLoader.load_Model_From_File("Models/tallbuilding1.fbx"); + tallBuildingModel.meshes.get(0).set_material(whiteMaterial); + Entity tallBuildingEntity1 = EntityUtil.spawnDrawableEntity(tallBuildingModel); + EntityUtil.getEntityRotation(tallBuildingEntity1) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(0) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(tallBuildingEntity1).set(200, 0.0f, -80); + EntityUtil.getEntityScale(tallBuildingEntity1).set(0.6f, 0.6f, 1f); + + Entity tallBuildingEntity2 = EntityUtil.spawnDrawableEntity(tallBuildingModel); + EntityUtil.getEntityRotation(tallBuildingEntity2) + .identity() + .rotateLocalX((float)(-Math.PI / 2)) + .rotateLocalY((float)(-(35) * Math.PI / 180)) + ; + EntityUtil.getEntityPosition(tallBuildingEntity2).set(190, 10.0f, 10.0f); + EntityUtil.getEntityScale(tallBuildingEntity2).set(0.5f, 0.5f, 1f); + } + +} diff --git a/src/main/java/net/Client.java b/src/main/java/net/Client.java new file mode 100644 index 00000000..76a14a5d --- /dev/null +++ b/src/main/java/net/Client.java @@ -0,0 +1,14 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package net; + +/** + * + * @author amaterasu + */ +public class Client { + +} diff --git a/src/main/java/net/Server.java b/src/main/java/net/Server.java new file mode 100644 index 00000000..6ecf220c --- /dev/null +++ b/src/main/java/net/Server.java @@ -0,0 +1,14 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package net; + +/** + * + * @author amaterasu + */ +public class Server { + +} diff --git a/src/main/java/util/ModelLoader.java b/src/main/java/util/ModelLoader.java new file mode 100644 index 00000000..8eae31f7 --- /dev/null +++ b/src/main/java/util/ModelLoader.java @@ -0,0 +1,85 @@ +package util; + +import main.Globals; +import RendererObjects.Material; +import RendererObjects.Mesh; +import RendererObjects.Model; +import RendererObjects.texture.Texture; +import RendererObjects.texture.TextureMap; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.lwjgl.assimp.AIScene; +import static org.lwjgl.assimp.Assimp.*; +import static org.lwjgl.assimp.Assimp.aiImportFile; + +public class ModelLoader { + public static Model load_Model_From_File(String fileName){ + Model rVal; + AIScene scene; + File file = new File(Thread.currentThread().getContextClassLoader().getResource(fileName).getFile()); + scene = aiImportFile(file.getAbsolutePath(), + aiProcess_GenSmoothNormals | + aiProcess_JoinIdenticalVertices | + aiProcess_Triangulate | + aiProcess_FixInfacingNormals | + aiProcess_LimitBoneWeights); + if(scene == null){ + throw new IllegalStateException(aiGetErrorString()); + } + rVal = Model.create_model_from_aiscene(scene); + attempt_add_textures_from_pathname(fileName, rVal); + return rVal; + } + + //TODO: this logic should exclusively use functions provided in the TextureMap class + //this way if we change the underlying structure of the TextureMap it doesn't fuck over this logic + static void attempt_add_textures_from_pathname(String path, Model m){ + //first we get the default texture map that's global + TextureMap global_map = Globals.texture_map_default; + //then we try to get the path of our model from the map + Map> mesh_map = global_map.get_mesh_map(path); + //if it exists.. + if(mesh_map != null){ + //iterate through each mesh in the model that was provided as input + Iterator mesh_iterator = m.meshes.iterator(); + while(mesh_iterator.hasNext()){ + Mesh current_mesh = mesh_iterator.next(); + //if the current iteration is contained within the mesh map we procured from above + if(mesh_map.containsKey(current_mesh.nodeID)){ + //we create a new material, check if the diffuse or specular is not null, + //and if they aren't we add that path as a new texture of respective type to the material + Material final_material = new Material(); + ArrayList texture_path_list = mesh_map.get(current_mesh.nodeID); + String diffuse_path = TextureMap.get_diffuse_path(texture_path_list); + if(diffuse_path != null){ + System.out.println(diffuse_path); + Texture diffuse = new Texture(diffuse_path); + final_material.set_diffuse(diffuse); + System.out.println(diffuse); + } else { + final_material.set_diffuse(Globals.texture_diffuse_default); + } + String specular_path = TextureMap.get_specular_path(texture_path_list); + if(specular_path != null){ + Texture specular = new Texture(specular_path); + final_material.set_specular(specular); + System.out.println(specular); + } else { + final_material.set_specular(Globals.texture_specular_default); + } + //once we've either added default textures or actual textures, + //set the current mesh's material to this new one + current_mesh.set_material(final_material); + } + } + } + } +} diff --git a/src/main/java/util/util.java b/src/main/java/util/util.java new file mode 100644 index 00000000..23a19873 --- /dev/null +++ b/src/main/java/util/util.java @@ -0,0 +1,234 @@ +package util; + +import RendererObjects.Material; +import RendererObjects.Mesh; +import RendererObjects.Model; +import RendererObjects.ShaderProgram; +import RendererObjects.texture.Texture; +import RendererObjects.texture.TextureMap; +import com.google.gson.Gson; +import java.io.File; +import java.io.IOException; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.joml.Matrix4f; +import org.joml.Vector3f; +import org.lwjgl.BufferUtils; +import org.lwjgl.assimp.AIMatrix4x4; +import static org.lwjgl.opengl.GL30.glBindVertexArray; +import static org.lwjgl.opengl.GL30.glGenVertexArrays; +/** + * + * @author awhoove + */ +public class util { + + + + public static Matrix4f convertAIMatrix(AIMatrix4x4 mat){ + Matrix4f rVal = new Matrix4f(); + //Old, wrong approach: +// mat.set( +// mat.a1(), +// mat.b1(), +// mat.c1(), +// mat.d1(), +// mat.a2(), +// mat.b2(), +// mat.c2(), +// mat.d2(), +// mat.a3(), +// mat.b3(), +// mat.c3(), +// mat.d3(), +// mat.a4(), +// mat.b4(), +// mat.c4(), +// mat.d4() +// ); + //as demo'd in https://github.com/lwjglgamedev/lwjglbook/blob/master/chapter27/c27-p2/src/main/java/org/lwjglb/engine/loaders/assimp/AnimMeshesLoader.java + rVal.m00(mat.a1()); + rVal.m10(mat.a2()); + rVal.m20(mat.a3()); + rVal.m30(mat.a4()); + rVal.m01(mat.b1()); + rVal.m11(mat.b2()); + rVal.m21(mat.b3()); + rVal.m31(mat.b4()); + rVal.m02(mat.c1()); + rVal.m12(mat.c2()); + rVal.m22(mat.c3()); + rVal.m32(mat.c4()); + rVal.m03(mat.d1()); + rVal.m13(mat.d2()); + rVal.m23(mat.d3()); + rVal.m33(mat.d4()); + return rVal; + } + + public static Model create_terrain_model(float[][] heightfield){ + Model rVal = new Model(); + rVal.meshes = new ArrayList(); + Mesh m = new Mesh(); + int width = heightfield.length; + int height = heightfield[0].length; + FloatBuffer vertices = BufferUtils.createFloatBuffer(width * height * 3); + FloatBuffer normals = BufferUtils.createFloatBuffer(width * height * 3); + IntBuffer faces = BufferUtils.createIntBuffer((width - 1) * (height - 1) * 2 * 3); + FloatBuffer texture_coords = BufferUtils.createFloatBuffer(width * height * 2); + for(int x = 0; x < width; x++){ + for(int y = 0; y < height; y++){ + //deal with vertex + vertices.put(x); + vertices.put(heightfield[x][y]); + vertices.put(y); + //deal with normal + if(x < width - 1){ + if(y < height - 1){ + float hL; + if(x > 0){ + hL = heightfield[x-1][y]; + } else { + hL = heightfield[x][y]; + } + float hR = heightfield[x+1][y]; + float hD = heightfield[x][y+1]; + float hU; + if(y > 0){ + hU = heightfield[x][y-1]; + } else { + hU = heightfield[x][y]; + } + Vector3f Normal = new Vector3f(hL - hR, 2.0f, hD - hU); + Normal.normalize(); + normals.put(Normal.x); + normals.put(Normal.y); + normals.put(Normal.z); + } else { + float hL; + if(x > 0){ + hL = heightfield[x-1][y]; + } else { + hL = heightfield[x][y]; + } + float hR = heightfield[x+1][y]; + float hD = heightfield[x][y]; + float hU = heightfield[x][y-1]; + Vector3f Normal = new Vector3f(hL - hR, 2.0f, hD - hU); + Normal.normalize(); + normals.put(Normal.x); + normals.put(Normal.y); + normals.put(Normal.z); + } + } else { + if(y < height - 1){ + float hL = heightfield[x-1][y]; + float hR = heightfield[x][y]; + float hD = heightfield[x][y+1]; + float hU; + if(y > 0){ + hU = heightfield[x][y-1]; + } else { + hU = heightfield[x][y]; + } + Vector3f Normal = new Vector3f(hL - hR, 2.0f, hD - hU); + Normal.normalize(); + normals.put(Normal.x); + normals.put(Normal.y); + normals.put(Normal.z); + } else { + float hL = heightfield[x-1][y]; + float hR = heightfield[x][y]; + float hD = heightfield[x][y]; + float hU = heightfield[x][y-1]; + Vector3f Normal = new Vector3f(hL - hR, 2.0f, hD - hU); + Normal.normalize(); + normals.put(Normal.x); + normals.put(Normal.y); + normals.put(Normal.z); + } + } + //deal with texture coordinates + if(x % 2 == 0){ + if(y % 2 == 0){ + texture_coords.put(0); + texture_coords.put(0); + } else { + texture_coords.put(0); + texture_coords.put(1); + } + } else { + if(y % 2 == 0){ + texture_coords.put(1); + texture_coords.put(0); + } else { + texture_coords.put(1); + texture_coords.put(1); + } + } + //deal with faces + if(x < width - 1 && y < height - 1){ + faces.put((x + 0) * height + (y + 0)); + faces.put((x + 0) * height + (y + 1)); + faces.put((x + 1) * height + (y + 0)); + faces.put((x + 1) * height + (y + 0)); + faces.put((x + 0) * height + (y + 1)); + faces.put((x + 1) * height + (y + 1)); + } + } + } + vertices.flip(); + normals.flip(); + faces.flip(); + texture_coords.flip(); + + m.vertexArrayObject = glGenVertexArrays(); + glBindVertexArray(m.vertexArrayObject); + //buffer vertices + m.buffer_vertices(vertices); + //buffer normals + m.buffer_normals(normals); + //buffer faces + m.buffer_faces(faces); + //buffer texture coords + m.buffer_texture_coords(texture_coords); + m.shader = ShaderProgram.smart_assemble_shader(false,true); + glBindVertexArray(0); + m.parent = rVal; + + Material grass_mat = new Material(); + Texture grass_texture = new Texture("Textures/grass_texture.jpg"); + grass_mat.set_diffuse(grass_texture); + grass_mat.set_specular(grass_texture); + m.set_material(grass_mat); + + rVal.meshes.add(m); + return rVal; + } + + public static void save_test_texture_map_to_location(String s){ + TextureMap t = new TextureMap(); + t.add_model("model1"); + t.add_mesh_to_model("model1", "mesh1"); + t.add_mesh_to_model("model1", "mesh2"); + t.add_mesh_to_model("model1", "mesh3"); + t.add_model("model2"); + t.add_mesh_to_model("model2", "mesh1"); + t.add_mesh_to_model("model2", "mesh2"); + t.add_model("model3"); + t.add_mesh_to_model("model3", "mesh1"); + t.add_mesh_to_model("model3", "mesh2"); + t.add_mesh_to_model("model3", "mesh3"); + t.add_mesh_to_model("model3", "mesh4"); + Gson gson = new Gson(); + try { + Files.write(new File(s).toPath(), gson.toJson(t).getBytes()); + } catch (IOException ex) { + ex.printStackTrace(); // just for testing :thinking: + } + } +} diff --git a/src/main/resources/Models/ArenaSpire1.fbx b/src/main/resources/Models/ArenaSpire1.fbx new file mode 100644 index 0000000000000000000000000000000000000000..d2f5894db044adf8a874e89a291842f005710ed8 GIT binary patch literal 16060 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 N+gkVM;NS literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/Wheat1.fbx b/src/main/resources/Models/Wheat1.fbx new file mode 100644 index 0000000000000000000000000000000000000000..ac19fc3da7a14b48121fa35f65baf9f8f657c6fe GIT binary patch literal 14876 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/arcdock5deg1Try2.fbx b/src/main/resources/Models/arcdock5deg1Try2.fbx new file mode 100644 index 0000000000000000000000000000000000000000..b17f32c147c71b8de0ad51eae30e8ba72726198a GIT binary patch literal 15516 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 G=Kla`7oTqc literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/groundplanemassiveuv.fbx b/src/main/resources/Models/groundplanemassiveuv.fbx new file mode 100644 index 0000000000000000000000000000000000000000..302a6a38815dce3530cfc5080c4cbdce2a667305 GIT binary patch literal 11532 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/tallbuilding1.fbx b/src/main/resources/Models/tallbuilding1.fbx new file mode 100644 index 0000000000000000000000000000000000000000..162ce0f5b44fb699f9e4fb9dba471c5699e68084 GIT binary patch literal 21628 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 z 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 T_+DmbX;5>MNUbMrx$yr1M7rWO literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/test3.fbx b/src/main/resources/Models/test3.fbx new file mode 100644 index 0000000000000000000000000000000000000000..447c9713b81fdaba3deea13104ae14142352abb7 GIT binary patch literal 63548 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 C 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 MtAA0ltX;ML0iBx2F8}}l literal 0 HcmV?d00001 diff --git a/src/main/resources/Models/test5.fbx b/src/main/resources/Models/test5.fbx new file mode 100644 index 0000000000000000000000000000000000000000..fdf380a3f3c1eda681062bcff21a516697a46958 GIT binary patch literal 14764 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 Qz4fgq8~VvLaMqCj1yYjz6#xJL literal 0 HcmV?d00001 diff --git a/src/main/resources/Shaders/FragmentShader.fs b/src/main/resources/Shaders/FragmentShader.fs new file mode 100644 index 00000000..06a3b4ea --- /dev/null +++ b/src/main/resources/Shaders/FragmentShader.fs @@ -0,0 +1,148 @@ + + +#version 430 core +out vec4 FragColor; + +struct Material { + sampler2D diffuse; + sampler2D specular; + float shininess; +}; + +struct DirLight { + vec3 direction; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct PointLight { + vec3 position; + + float constant; + float linear; + float quadratic; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct SpotLight { + vec3 position; + vec3 direction; + float cutOff; + float outerCutOff; + + float constant; + float linear; + float quadratic; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +#define NR_POINT_LIGHTS 10 + +in vec3 FragPos; +in vec3 Normal; +in vec2 TexCoord; + +uniform vec3 viewPos; +uniform DirLight dirLight; +uniform PointLight pointLights[NR_POINT_LIGHTS]; +uniform SpotLight spotLight; +uniform Material material; + +//texture stuff +uniform sampler2D ourTexture; +uniform int hasTransparency; + + +// function prototypes +vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir); +vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir); +vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir); + +void main(){ + if(hasTransparency == 1){ + if(texture(material.diffuse, TexCoord).a < 0.1){ + discard; + } + } + vec3 norm = normalize(Normal); + vec3 viewDir = normalize(viewPos - FragPos); + + vec3 result = CalcDirLight(dirLight, norm, viewDir); + //for(int i = 0; i < NR_POINT_LIGHTS; i++){ + // result += CalcPointLight(pointLights[i], norm, FragPos, viewDir); + //} + //result += CalcSpotLight(spotLight, norm, FragPos, viewDir); + FragColor = vec4(result, texture(material.diffuse, TexCoord).a);//texture(ourTexture, TexCoord);//vec4(result, 1.0); +} + +// calculates the color when using a directional light. +vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir){ + vec3 lightDir = normalize(-light.direction); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // combine results + vec3 texColor = texture(material.diffuse, TexCoord).rgb; + vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoord).rgb); + vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoord).rgb); + //vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoord).rgb); + return (ambient + diffuse);// + specular); +} + + +// calculates the color when using a point light. +vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir){ + vec3 lightDir = normalize(light.position - fragPos); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // attenuation + float distance = length(light.position - fragPos); + float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); + // combine results + vec3 ambient = light.ambient * vec4(texture(material.diffuse, TexCoord)).xyz; + vec3 diffuse = light.diffuse * diff * vec4(texture(material.diffuse, TexCoord)).xyz; + vec3 specular = light.specular * spec * vec4(texture(material.specular, TexCoord)).xyz; + ambient *= attenuation; + diffuse *= attenuation; + specular *= attenuation; + return (ambient + diffuse + specular); +} + +// calculates the color when using a spot light. +vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir) +{ + vec3 lightDir = normalize(light.position - fragPos); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // attenuation + float distance = length(light.position - fragPos); + float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); + // spotlight intensity + float theta = dot(lightDir, normalize(-light.direction)); + float epsilon = light.cutOff - light.outerCutOff; + float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0); + // combine results + vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoord)); + vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoord)); + vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoord)); + ambient *= attenuation * intensity; + diffuse *= attenuation * intensity; + specular *= attenuation * intensity; + return (ambient + diffuse + specular); +} \ No newline at end of file diff --git a/src/main/resources/Shaders/VertexShader.vs b/src/main/resources/Shaders/VertexShader.vs new file mode 100644 index 00000000..be244168 --- /dev/null +++ b/src/main/resources/Shaders/VertexShader.vs @@ -0,0 +1,56 @@ +//Vertex Shader +#version 430 core + + + +//input buffers +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; +layout (location = 2) in vec4 aWeights; +layout (location = 3) in vec4 aIndex; +layout (location = 4) in vec2 aTex; + + +//coordinate space transformation matrices +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +//bone related variables +const int MAX_WEIGHTS = 4; +const int MAX_BONES = 100; +uniform mat4 bones[MAX_BONES]; +uniform int hasBones; +uniform int numBones; + + + +//output buffers +out vec3 Normal; +out vec3 FragPos; +out vec2 TexCoord; + + + + +void main() +{ + //calculate bone transform + mat4 BoneTransform = (bones[int(aIndex[0])] * aWeights[0]); + BoneTransform = BoneTransform + (bones[int(aIndex[1])] * aWeights[1]); + BoneTransform = BoneTransform + (bones[int(aIndex[2])] * aWeights[2]); + BoneTransform = BoneTransform + (bones[int(aIndex[3])] * aWeights[3]); + //apply bone transform to position vectors + vec4 FinalVertex = BoneTransform * vec4(aPos, 1.0); + vec4 FinalNormal = BoneTransform * vec4(aNormal, 1.0); + //make sure the W component is 1.0 + FinalVertex = vec4(FinalVertex.xyz, 1.0); + FinalNormal = vec4(FinalNormal.xyz, 1.0); + //push frag, normal, and texture positions to fragment shader + FragPos = vec3(model * FinalVertex); + Normal = mat3(transpose(inverse(model))) * aNormal; + TexCoord = aTex; + //set final position with opengl space + gl_Position = projection * view * model * FinalVertex; +} \ No newline at end of file diff --git a/src/main/resources/Shaders/VertexShaderNoBones.vs b/src/main/resources/Shaders/VertexShaderNoBones.vs new file mode 100644 index 00000000..a7060dd9 --- /dev/null +++ b/src/main/resources/Shaders/VertexShaderNoBones.vs @@ -0,0 +1,39 @@ +//Vertex Shader +#version 430 core + + + +//input buffers +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; +layout (location = 4) in vec2 aTex; + + +//coordinate space transformation matrices +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + + + +//output buffers +out vec3 Normal; +out vec3 FragPos; +out vec2 TexCoord; + + + + +void main() +{ + //normalize posiiton and normal + vec4 FinalVertex = vec4(aPos, 1.0); + vec4 FinalNormal = vec4(aNormal, 1.0); + //push frag, normal, and texture positions to fragment shader + FragPos = vec3(model * FinalVertex); + Normal = mat3(transpose(inverse(model))) * aNormal; + TexCoord = aTex; + //set final position with opengl space + gl_Position = projection * view * model * FinalVertex; +} diff --git a/src/main/resources/Shaders/backup/FragmentShader.fs b/src/main/resources/Shaders/backup/FragmentShader.fs new file mode 100644 index 00000000..b9c17f24 --- /dev/null +++ b/src/main/resources/Shaders/backup/FragmentShader.fs @@ -0,0 +1,165 @@ + + +#version 430 core +out vec4 FragColor; + +struct Material { + sampler2D diffuse; + sampler2D specular; + float shininess; +}; + +struct DirLight { + vec3 direction; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct PointLight { + vec3 position; + + float constant; + float linear; + float quadratic; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct SpotLight { + vec3 position; + vec3 direction; + float cutOff; + float outerCutOff; + + float constant; + float linear; + float quadratic; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +#define NR_POINT_LIGHTS 4 + +in vec3 FragPos; +in vec3 Normal; +in vec2 TexCoords; + + +uniform int fragHasTexture; + +uniform vec3 viewPos; +uniform DirLight dirLight; +uniform PointLight pointLights[NR_POINT_LIGHTS]; +uniform SpotLight spotLight; +uniform Material material; + +// function prototypes +vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir); +vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir); +vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir); + +void main() +{ + // properties + vec3 norm = normalize(Normal); + vec3 viewDir = normalize(viewPos - FragPos); + + // == ===================================================== + // Our lighting is set up in 3 phases: directional, point lights and an optional flashlight + // For each phase, a calculate function is defined that calculates the corresponding color + // per lamp. In the main() function we take all the calculated colors and sum them up for + // this fragment's final color. + // == ===================================================== + // phase 1: directional lighting + vec3 result = CalcDirLight(dirLight, norm, viewDir); + // phase 2: point lights + //for(int i = 0; i < NR_POINT_LIGHTS; i++) + // result += CalcPointLight(pointLights[i], norm, FragPos, viewDir); + // phase 3: spot light + //result += CalcSpotLight(spotLight, norm, FragPos, viewDir); + + FragColor = vec4(result, 1.0); +} + +// calculates the color when using a directional light. +vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir) +{ + vec3 lightDir = normalize(-light.direction); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // combine results + vec3 ambient = vec3(1.0,1.0,1.0); + vec3 diffuse = vec3(1.0,1.0,1.0); + vec3 specular = vec3(1.0,1.0,1.0); + if(fragHasTexture == 1){ + ambient = light.ambient;// * vec3(texture(material.diffuse, TexCoords)); + diffuse = light.diffuse * diff;// * vec3(texture(material.diffuse, TexCoords)); + specular = light.specular * spec;// * vec3(texture(material.specular, TexCoords)); + } else { + ambient = light.ambient;// * vec3(texture(material.diffuse, TexCoords)); + diffuse = light.diffuse * diff;// * vec3(texture(material.diffuse, TexCoords)); + specular = light.specular * spec;// * vec3(texture(material.specular, TexCoords)); + } + //vec3 ambient = light.ambient;// * vec3(texture(material.diffuse, TexCoords)); + //vec3 diffuse = light.diffuse * diff;// * vec3(texture(material.diffuse, TexCoords)); + //vec3 specular = light.specular * spec;// * vec3(texture(material.specular, TexCoords)); + return (ambient + diffuse);// + specular); +} + +// calculates the color when using a point light. +vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir) +{ + vec3 lightDir = normalize(light.position - fragPos); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // attenuation + float distance = length(light.position - fragPos); + float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); + // combine results + vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); + vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords)); + vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); + ambient *= attenuation; + diffuse *= attenuation; + specular *= attenuation; + return (ambient + diffuse + specular); +} + +// calculates the color when using a spot light. +vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir) +{ + vec3 lightDir = normalize(light.position - fragPos); + // diffuse shading + float diff = max(dot(normal, lightDir), 0.0); + // specular shading + vec3 reflectDir = reflect(-lightDir, normal); + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + // attenuation + float distance = length(light.position - fragPos); + float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); + // spotlight intensity + float theta = dot(lightDir, normalize(-light.direction)); + float epsilon = light.cutOff - light.outerCutOff; + float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0); + // combine results + vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); + vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords)); + vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); + ambient *= attenuation * intensity; + diffuse *= attenuation * intensity; + specular *= attenuation * intensity; + return (ambient + diffuse + specular); +} + diff --git a/src/main/resources/Shaders/backup/NewVertexShader.vs b/src/main/resources/Shaders/backup/NewVertexShader.vs new file mode 100644 index 00000000..01885edb --- /dev/null +++ b/src/main/resources/Shaders/backup/NewVertexShader.vs @@ -0,0 +1,97 @@ +//Vertex Shader +#version 430 core + + + + +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; +layout (location = 2) in vec4 aWeights; +layout (location = 3) in vec4 aIndex; +layout (location = 4) in vec2 aText; + + + +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + + +const int MAX_BONES = 100; +uniform mat4 bones[MAX_BONES]; +uniform int hasBones; +uniform int numBones; + +uniform int hasTexture; + + + +out vec3 Normal; +out vec3 FragPos; +out vec2 TexCoords; + + + + +void main() +{ + vec4 FinalVertex = vec4(aPos, 1.0); + vec4 FinalNormal = vec4(aNormal, 0.0); + if(hasBones == 1){ + //mat4 BoneTransform; + //for(int i = 0; i < MAX_BONES; i++){ + // if(i < numBones){ + // BoneTransform += bones[i] * aWeights[i]; + // } + //} + //vec4 FinalVertex = vec4(aPos, 1.0); + //vec4 FinalNormal = vec4(aNormal, 1.0); + //mat4 BoneTransform; + //BoneTransform = mat4( + // 1.0,0.0,0.0,0.0, + // 0.0,1.0,0.0,0.0, + // 0.0,0.0,1.0,0.0, + // 0.0,0.0,0.0,1.0); + //BoneTransform = BoneTransform * mat4( + // 1.0,0.0,0.0,0.0, + // 0.0,1.0,0.0,0.0, + // 0.0,0.0,2.0,0.0, + // 0.0,0.0,0.0,1.0); + //BoneTransform = BoneTransform * bones[aIndex[0]] * aWeights[0]; + //BoneTransform += bones[aIndex[0]] * 1.0; + //BoneTransform += bones[aIndex[1]] * aWeights[1]; + //BoneTransform += bones[aIndex[2]] * aWeights[2]; + //BoneTransform += bones[aIndex[3]] * aWeights[3]; + //FinalVertex = BoneTransform * FinalVertex; + vec4 inputVertex = FinalVertex; + vec4 inputNormal = FinalNormal; + //mat4 BoneTransform; + //BoneTransform = bones[int(aIndex[0])] * aWeights[0]; + //BoneTransform += bones[int(aIndex[1])] * aWeights[1]; + //BoneTransform += bones[int(aIndex[2])] * aWeights[2]; + //BoneTransform += bones[int(aIndex[3])] * aWeights[3]; + //FinalVertex = BoneTransform * inputVertex; + //FinalNormal = BoneTransform * inputNormal; + FinalVertex = (bones[int(aIndex[0])] * inputVertex) * aWeights[0]; + FinalVertex = (bones[int(aIndex[1])] * inputVertex) * aWeights[1] + FinalVertex; + FinalVertex = (bones[int(aIndex[2])] * inputVertex) * aWeights[2] + FinalVertex; + FinalVertex = (bones[int(aIndex[3])] * inputVertex) * aWeights[3] + FinalVertex; + FinalNormal = (bones[int(aIndex[0])] * inputNormal) * aWeights[0]; + FinalNormal = (bones[int(aIndex[1])] * inputNormal) * aWeights[1] + FinalNormal; + FinalNormal = (bones[int(aIndex[2])] * inputNormal) * aWeights[2] + FinalNormal; + FinalNormal = (bones[int(aIndex[3])] * inputNormal) * aWeights[3] + FinalNormal; + } else { + //gl_Position = projection * view * model * vec4(aPos, 1.0); + } + + vec2 FinalTexture = vec2(1.0,1.0); + if(hasTexture == 1){ + FinalTexture = aText; + } + TexCoords = FinalTexture; + + FragPos = vec3(model * FinalVertex); + Normal = vec3(transpose(inverse(model)) * FinalNormal); + gl_Position = projection * view * model * FinalVertex; +} \ No newline at end of file diff --git a/src/main/resources/Shaders/old/LampShader.fs b/src/main/resources/Shaders/old/LampShader.fs new file mode 100644 index 00000000..34b7eeca --- /dev/null +++ b/src/main/resources/Shaders/old/LampShader.fs @@ -0,0 +1,13 @@ +//Fragment Shader +#version 330 core + + +out vec4 FragColor; + +uniform vec3 objectColor; +uniform vec3 lightColor; + +void main() +{ +FragColor = vec4(1.0); +} diff --git a/src/main/resources/Shaders/old/VertexShader.vs b/src/main/resources/Shaders/old/VertexShader.vs new file mode 100644 index 00000000..b1013f2a --- /dev/null +++ b/src/main/resources/Shaders/old/VertexShader.vs @@ -0,0 +1,68 @@ +//Vertex Shader +#version 430 core + + + + +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; +layout (location = 2) in vec4 aWeights; +layout (location = 3) in ivec4 aIndex; + + + +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + + +const int MAX_BONES = 100; +uniform mat4 bones[MAX_BONES]; +uniform int hasBones; +uniform int numBones; + + + +out vec3 Normal; +out vec3 FragPos; +out vec2 TexCoords; + + + +void main() +{ + if(hasBones == 1){ + //mat4 BoneTransform; + //for(int i = 0; i < MAX_BONES; i++){ + // if(i < numBones){ + // BoneTransform += bones[i] * aWeights[i]; + // } + //} + mat4 BoneTransform; + BoneTransform = mat4( + 1.0,0.0,0.0,0.0, + 0.0,1.0,0.0,0.0, + 0.0,0.0,1.0,0.0, + 0.0,0.0,0.0,1.0); + //BoneTransform = BoneTransform * mat4( + // 1.0,0.0,0.0,0.0, + // 0.0,1.0,0.0,0.0, + // 0.0,0.0,2.0,0.0, + // 0.0,0.0,0.0,1.0); + BoneTransform = BoneTransform * bones[aIndex[0]] * aWeights[0]; + BoneTransform += BoneTransform * bones[aIndex[1]] * aWeights[1]; + BoneTransform += BoneTransform * bones[aIndex[2]] * aWeights[2]; + BoneTransform += BoneTransform * bones[aIndex[3]] * aWeights[3]; + //BoneTransform += bones[aIndex[0]] * 1.0; + //BoneTransform += bones[aIndex[1]] * aWeights[1]; + //BoneTransform += bones[aIndex[2]] * aWeights[2]; + //BoneTransform += bones[aIndex[3]] * aWeights[3]; + gl_Position = projection * view * model * BoneTransform * vec4(aPos, 1.0); + } else { + gl_Position = projection * view * model * vec4(aPos, 1.0); + } + FragPos = vec3(model * vec4(aPos, 1.0)); + Normal = vec3(vec4(aNormal, 1.0)); + TexCoords = vec2(0.5, 0.5); +} \ No newline at end of file diff --git a/src/main/resources/Shaders/old/old shader code b/src/main/resources/Shaders/old/old shader code new file mode 100644 index 00000000..ebace10c --- /dev/null +++ b/src/main/resources/Shaders/old/old shader code @@ -0,0 +1,61 @@ +//Vertex Shader +#version 330 core +layout (location = 0) in vec3 aPos; +//layout (location = 1) in vec3 aColor; +//layout (location = 1) in vec2 aTexCoord; +//layout (location = 2) in vec3 aNormal; + +//out vec3 ourColor; + +//uniform vec3 offset; + +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +//out vec3 ourPos; +//out vec2 TexCoord; +//out vec3 FragPos; +//out vec3 Normal; +void main() +{ +//gl_Position = vec4(aPos, 1.0); +gl_Position = projection * view * model * vec4(aPos, 1.0); +//ourColor = aColor; +//FragPos = vec3(model * vec4(aPos, 1.0)); +//TexCoord = aTexCoord; +//Normal = mat3(transpose(inverse(model))) * aNormal; +} + + + + + +//Fragment Shader +#version 330 core + + +out vec4 FragColor; + +//in vec3 ourColor; + +//in vec2 TexCoord; +//uniform sampler2D ourTexture1; +//uniform sampler2D ourTexture2; +//in vec3 Normal; +//uniform vec3 lightPos; +//in vec3 FragPos; + + +void main() +{ +//vec3 lightColor = vec3(1.0, 1.0, 1.0); +//vec3 norm = normalize(Normal); +//vec3 lightDir = normalize(lightPos - FragPos); +//float diff = max(dot(Normal, lightDir), 0.0); +//vec3 diffuse = diff * lightColor; +//vec3 result = diffuse * objectColor; +//FragColor = mix(texture(ourTexture1, TexCoord), texture(ourTexture2, TexCoord), 0.2);// - (vec4(diffuse, 1.0)*0.2);// * vec4(ourColor, 1.0); +FragColor = vec4(0.5, 0.5, 0.5, 1.0); +} diff --git a/src/main/resources/Shaders/old/oldFragShader.fs b/src/main/resources/Shaders/old/oldFragShader.fs new file mode 100644 index 00000000..e429040f --- /dev/null +++ b/src/main/resources/Shaders/old/oldFragShader.fs @@ -0,0 +1,34 @@ +//Fragment Shader +#version 330 core + +in vec3 FragPos; +in vec3 Normal; + +uniform vec3 objectColor; +uniform vec3 lightColor; +uniform vec3 lightPos; +uniform vec3 viewPos; + +out vec4 FragColor; + +void main() +{ +//Diffuse calculations.. +vec3 norm = normalize(Normal); +vec3 lightDir = normalize(lightPos - FragPos); +float diff = max(dot(norm, lightDir), 0.0); +vec3 diffuse = diff * lightColor; +//Ambient Light +float ambientStrength = 0.5; +vec3 ambient = ambientStrength * lightColor; +//Specular calculations.. +float specularStrength = 0.5; +vec3 viewDir = normalize(viewPos - FragPos); +vec3 reflectDir = reflect(-lightDir, norm); +float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32); +vec3 specular = specularStrength * spec * lightColor; +//result color +vec3 result = (ambient + diffuse + specular) * objectColor; +//push output color +FragColor = vec4(result, 1.0); +} diff --git a/src/main/resources/Shaders/skybox/FragmentShaderNoTexture.fs b/src/main/resources/Shaders/skybox/FragmentShaderNoTexture.fs new file mode 100644 index 00000000..37c682b3 --- /dev/null +++ b/src/main/resources/Shaders/skybox/FragmentShaderNoTexture.fs @@ -0,0 +1,13 @@ + + +#version 430 core +out vec4 FragColor; + + +in vec3 color; + + +void main() +{ + FragColor = vec4(color, 1.0); +} \ No newline at end of file diff --git a/src/main/resources/Shaders/skybox/VertexShaderNoTexture.vs b/src/main/resources/Shaders/skybox/VertexShaderNoTexture.vs new file mode 100644 index 00000000..a01f7301 --- /dev/null +++ b/src/main/resources/Shaders/skybox/VertexShaderNoTexture.vs @@ -0,0 +1,34 @@ +//Vertex Shader +#version 430 core + + + +//input buffers +layout (location = 0) in vec3 aPos; +layout (location = 1) in float id; + + +//coordinate space transformation matrices +uniform mat4 transform; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + + + +uniform vec3 colors[8]; + +out vec3 color; + + + +void main() +{ + //normalize posiiton and normal + vec4 FinalVertex = vec4(aPos, 1.0); + //send color to the frag shader + color = colors[int(id)]; + //set final position with opengl space + vec4 pos = projection * view * FinalVertex; + gl_Position = pos.xyww; +} diff --git a/src/main/resources/Textures/Fonts/OpenSansBitmap.bmp b/src/main/resources/Textures/Fonts/OpenSansBitmap.bmp new file mode 100644 index 0000000000000000000000000000000000000000..f22aaa375aeeacaf47746ae67d83cbf74391440b GIT binary patch literal 196662 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/Ground/Dirt1.png b/src/main/resources/Textures/Ground/Dirt1.png new file mode 100644 index 0000000000000000000000000000000000000000..61b45cccb23bafd0d6e4834d9cfb69c050d6380f GIT binary patch literal 45406 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

>jWR1OlbeoCqYx@YyKl<~P5%B@?^8 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/Spaceplane.png b/src/main/resources/Textures/Spaceplane.png new file mode 100644 index 0000000000000000000000000000000000000000..90b7626c0cae4667e46b290f697bfd1a04199509 GIT binary patch literal 30275 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

;xjxrD2*^Ebhm5`?j!a6;^jHT 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/Wheat1stretch.png b/src/main/resources/Textures/Wheat1stretch.png new file mode 100644 index 0000000000000000000000000000000000000000..34fea034038a1aa5d90f66415fd1dfc4558dfdcb GIT binary patch literal 12900 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 Z(7jQ4_!y;u{MiUVMd6KnjjUPd{{XGOBJ2PF literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/default_diffuse.png b/src/main/resources/Textures/default_diffuse.png new file mode 100644 index 0000000000000000000000000000000000000000..391b90abf39cd002808e0ec043b02702bfc921dc GIT binary patch literal 967 zcmV;&133JNP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D16)Z&K~z{r?Uze0 zYf%`6wRNvnU4kNwOQMLlMienJ>t8VN8yFgyi6793n3x-hFfb*8XyqUh#I@qq1`Vyd z^W^Lman4Ei?sAL4dInYN+iUmzzV+?3-fen$c}e zcX#La`@`XIXJ@Cw;V_v@B4EVx^Yhi!mDy~zTCK^+$zoI=WF^AW)6@9)cxh=Vf_i#- z&d<+9z=-SXYoE{8($do0+&nfm7L7(lK$k>iU0z;xcXw+QN>5K89UT<`BPJ#$a&mIC z5)>8|&d<+_fG&ylRz^mK+wEo{P?nXIRa8_Y0!G+uw$#*AEuXZsv{#7+2zf@(AIHbX z0|NuSy}hjF&CQJn7;$=f+Sk`d8Za_4a({m>0=j&;u_2#OD73M$L8+RWn)nm}U6kLF zLCKOq$&w+itjEX4U@*w1`2Tx}D{FguduV8AWo3npM+|)ludj1X zi_!1GGB`LWzWxm+1Z7K0OS`+fDJdy-yPXlvL=pZ}*wQ)8Fi!lCc6!E@m7SekTU&c} zcDA*(g+5LXJQFjS#sOlnSj2T7hI_89txZl&VwQ@Fi?JsR>K#6G)#2eG&SZ9W7Fmpx zl$2CeRn^ti@mXG8?sPiIPrFzaZjO%4%}uQ3+}zy${(fs~Ykz-#MMVWsgENsR#_izX zV0n3&`P>Dev|4_CKFV-*ZEbDU)z#P@F~JCK7>mVz{b6-=H4q43Oz04NBHqN~@o0G_ zdQ>BYQoQztw1c4d7Z(?#$P-HOahv!SY$qnMrly7^$j!~AFR_aJDyajTA5$nf`7A6f z(5!iRc@zdIWW_|R;y=l}-`Jp!*9}&d^<_DBc6Knepwn!r&m}Jim|u1$10s+P4Rr#RhVCgVE29e=8XD^B z>kA4B^!J*N%6iMg!$TwzK@jl5gFi+SgUF(UbRNE0r}^IUnX*2SFWI#}j*=yVk|l$Z pC4-VBgOVkKk|l$Zl{iUBzX6Iq5H=$T2H5}r002ovPDHLkV1g#V!W94j literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/default_specular.png b/src/main/resources/Textures/default_specular.png new file mode 100644 index 0000000000000000000000000000000000000000..391b90abf39cd002808e0ec043b02702bfc921dc GIT binary patch literal 967 zcmV;&133JNP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D16)Z&K~z{r?Uze0 zYf%`6wRNvnU4kNwOQMLlMienJ>t8VN8yFgyi6793n3x-hFfb*8XyqUh#I@qq1`Vyd z^W^Lman4Ei?sAL4dInYN+iUmzzV+?3-fen$c}e zcX#La`@`XIXJ@Cw;V_v@B4EVx^Yhi!mDy~zTCK^+$zoI=WF^AW)6@9)cxh=Vf_i#- z&d<+9z=-SXYoE{8($do0+&nfm7L7(lK$k>iU0z;xcXw+QN>5K89UT<`BPJ#$a&mIC z5)>8|&d<+_fG&ylRz^mK+wEo{P?nXIRa8_Y0!G+uw$#*AEuXZsv{#7+2zf@(AIHbX z0|NuSy}hjF&CQJn7;$=f+Sk`d8Za_4a({m>0=j&;u_2#OD73M$L8+RWn)nm}U6kLF zLCKOq$&w+itjEX4U@*w1`2Tx}D{FguduV8AWo3npM+|)ludj1X zi_!1GGB`LWzWxm+1Z7K0OS`+fDJdy-yPXlvL=pZ}*wQ)8Fi!lCc6!E@m7SekTU&c} zcDA*(g+5LXJQFjS#sOlnSj2T7hI_89txZl&VwQ@Fi?JsR>K#6G)#2eG&SZ9W7Fmpx zl$2CeRn^ti@mXG8?sPiIPrFzaZjO%4%}uQ3+}zy${(fs~Ykz-#MMVWsgENsR#_izX zV0n3&`P>Dev|4_CKFV-*ZEbDU)z#P@F~JCK7>mVz{b6-=H4q43Oz04NBHqN~@o0G_ zdQ>BYQoQztw1c4d7Z(?#$P-HOahv!SY$qnMrly7^$j!~AFR_aJDyajTA5$nf`7A6f z(5!iRc@zdIWW_|R;y=l}-`Jp!*9}&d^<_DBc6Knepwn!r&m}Jim|u1$10s+P4Rr#RhVCgVE29e=8XD^B z>kA4B^!J*N%6iMg!$TwzK@jl5gFi+SgUF(UbRNE0r}^IUnX*2SFWI#}j*=yVk|l$Z pC4-VBgOVkKk|l$Zl{iUBzX6Iq5H=$T2H5}r002ovPDHLkV1g#V!W94j literal 0 HcmV?d00001 diff --git a/src/main/resources/Textures/default_texture_map.json b/src/main/resources/Textures/default_texture_map.json new file mode 100644 index 00000000..d4e44029 --- /dev/null +++ b/src/main/resources/Textures/default_texture_map.json @@ -0,0 +1,22 @@ +{ + "texture_map": { + "Models/plane.fbx": { + "Cube": [ + "Textures/Ground/Dirt1.png", + "Textures/Ground/Dirt1.png" + ] + }, + "Models/arcdock5deg1notex.fbx": { + "Cube": [ + "Textures/w1.png", + "Textures/w1.png" + ] + }, + "Models/Wheat1.fbx": { + "Stalk": [ + "Textures/Wheat1stretch.png", + "Textures/Wheat1stretch.png" + ] + } + } +} \ No newline at end of file diff --git a/src/main/resources/Textures/leaves.png b/src/main/resources/Textures/leaves.png new file mode 100644 index 0000000000000000000000000000000000000000..7f1474e17156066ed5080b9ddec27def84132883 GIT binary patch literal 71433 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

    #9PlD-zrl6mgJgoO1nQu@# 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

    r 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

    3^tN`zrOyMY^JkMN62yuq9$+htiKJI4 z#0$a7x5ow93^;i&np#GD22wvuY3^5+OWwuURXyd^&?}p&d}?Ou!YFpm04`_crI7Ue z@NX}*KAXMcE=S&~+{Zk!-|`@K1ekgKS^GnsD2}=IQUuvCm2$Z%GD<@Ep>9AJ9zRDI zjC=6Nq-v^c%CVXn?i4=dG}j#XD#MaS*=^mUL9c432)k%f{~+u#s(Enq;|I!a)wFK6 zL_1BZYxw)`wxaPZZh!Mf_g>Z$u<&x&J=&+^;PeT{2t^!D6Z{}3D&ksw4DWf>pe7)u zPv8O&|C;5$h!|iOo3|;;UHlVVbws* zcLMc%ZrqZrK$%w2G4DARIXpCOz`BCUfbBE&c6SCxMX2)4o;sXLl=OVie$5iqf^p#z z$|frLe4Rp=nQGlgDt|e`27-l%NitY- zHOho`ul4o(U-`N&HoHGSyE9P7tjrm}pG4^za)a#&?K$w_hD(OH%m+O>95Sym4&(Tf z1vT~L#?+QRvOnw?fj%FWI}jpgPqQ0ikmQpba^rqytA!N<)%S)XJu|qohJFj;+L+U@ z5L0*6aVs0voq3y1t$!en(VY^+;c%K_v=@7x%+|NPjkU(rZ`Vl3_?hWaoJmKHyQqd&?@2S?}h*%sTsr*Bj_P z!ODRL7M`9M9d%)ZSRHKpXM=x6LgHLviSP8hS8Pyo>_i~(!}UUI={6ME$={wIcSd3= z;+GWeVbfA1b@oHRGxn-1y~<_LSjgKrx$vro9r-&KChz`v>67n{kWt!WyP~IqBf14u z#D-{G9c1O#IYyv|rDDi+?xdiK%jB#WqjZmGlC|Dtr)MADoiX%LMP&shY@sSpFaZ+QphhaUxy+>7$8Cf}=Ce&Rp7;cXF%=v;hyRpOyzVz4u zL7K-ux8^TT7_b@G3AC3ZKbV+{@)>Y%5ZN%mar-)1nREkcba~WtA&UUu*U?&KdTs`UW%F(ExY2qBK15>L@I7n=&VvR$=9(;g|EMHejz^ROpC zy&=ujk?zx$epB2E08kB#S^oO&d#5z3xh)&jcIO+r2KNafK7P~qDTL(7H%GEC?OpR1ocgP@X&NW`**iO!_qvY=$oXP}b>m-LS`DmYRWiM954??gC{C6IY%{uN8k zawvc}nn|p(t;WcJGPTGax??iOqC6|eI9AP1`#P5d>=$Dpkiq>)uep)G&x>WsKmJTF~%- zuz>)+r@&Bc%%zaEc1Beyi=BXhKYi!gLtn~&cXKo}{7N=&!BHr4$Vu_#`<%$H*6X{c zr|O{t!6@oP2>Cj!9g;kV#Ho{X1!Pdlj1_vHnfC z-x0+!P?*nX*Q@UptZh#tuN6TdDmRu4mG$b-0w6}cBp)k)nJpp|AC9{}4Euu`YldEk z?PSU5YhLK2h@wiLQwPb(;Cz;u;cNZ?W3{UV!#n?Cb9(1)A(q3ry`B5Qowo7W)O;Hi zD}f4|!?re|l~H6&B*+lo5kW~h;u`M^d<-_{zkoy-Men*x`c^K}GB?rUSz7y%OL5_8 zQ;T|;{#?YRwK3Ig8k@UEDWMHS9dz_X1Ne$&^Ue6UcfSEMN&TB;_>S zJsAFx7>R5(oud3b6fYqkVB87$@;qdbrcwq_5ZfoLpqIZEJh`aXlGg<{rpc^XRzO=LEoy|6+nV)~;bG6r@rnjT5txKzf z*7tSK#6Ng<=z}YygKN2~%ho`hK|$saZTC{unqp<2I3>g~ zL73(fDrU+smr*=irusG}u1A?gjoCiM3-PZM;g+;N$v|o%GB@AqNr+ihN;Q8BdZdMH z%F8}JrA12q?PtA`eFS)4dfI`5R75^v64s?G)T-hm#)T)bK#7aJx*~Y3=!+`1*oM@@ znsYKEw!tw063)m)PmCxS`4f-J*ST4r)y_P<4SzF^LVVoJ3W3Y!Sy_Cop>Bxu^8eA0m_a9XuT(Y zRfSOuWu)PG#ifn`IEG;6oQ{+Q7in2OIQd5tpCI>8mhb9ig=B)rA_Xm3_YWUeN`#7B z9B~(XoXm|uct??Sn!1diE++SDxX1Rqaz6l)&#uFrc;wuF+>Xjh7tw{XpaF$ zc|FdGJNS+)2nx8@TpA%!ZUWJDKzNVy4t6qe8YmIttAi*%2j0^~j2v9Z(Fw7XDZ)Ax zCGCRca`Ly5|2T|y#?=!d5!hcuCA`JUq%%VSS*V6!qA^NG3-XN7+U8Lo?ZK>m@lhkV z++Wm)wx17v_T!NXd7DswY}yF>hQwNJtjs?J7rGh?qhvb? zDJeg`$9({)CR{;);S%&%oOz_}?($lxvaMKJrS+}CG@o)CAse3=(nHxcUnBF%?jBWB z;jncVPfU0(2rd^wTJa&!ilivcbK)43uVCv#t5(ejHc`#gtii!Ob$nEZVnIPkxSt~K zP&Z>48#WG+C4JYCmW2CEHvzf)mCP8-PhJa7Gpim=@nifnAUbzXf9Lk*prWGUDBsVw z4zDinpb^}4n2*)HE=npzy{KKT>f++!(Y%Zwx^V+KUvZ7fPxNFJ)PKWyP98%}1cw-7 zBkSJB$xi2$_zgT$L;}HYf6CyRGBNR1L$p>z`v?;8I5Qt}l23!aHsRdlWA^t+-p8&2 z*!vIYpWj~(RuhkDk4q`k)Kkk^Ge9M)aU(fko2*zI6|^D%;S=_$z&`P>OoiRa)$Fy{aE%M-=hL6%RnBz!XI%zvAtZSF zad>hcby9r8Yc$mGWTV(FR)tI35@MEp41pQL#gmAGY|(yOD=v=CYv zs!L~&7iLLo^b^j{1@>rg%1fm73ti3aTm_;&(kj1afCfNx$`-h&UZhu=;P=iqHjr!7 zbd1=R{c`l~#443F9V6yr{oeHqJmaLe+#t&-rAF|Y3K|dRd8=SjIv-4+{NAv7%gVA^ zv&4egkV9E>1XUWs=G&q?#yzqoBhDMWk|M!|EfMA(E${wJxmJ_X^61o(A6*!q-`=)0 z^E!H(fdI2!-(+FhsXAc5t%Coe}B)f z%rigRVURxBj66wq))DvFy_}uJzzBQJ&QdMiS6XWA3NHVGK`F2ihl%e5U0*_@xQ8#m zLg|B{9VV@i=(nQ=!`TOKj!rwwqNDx}7}rRv#Zi)-3Vbg;j5YJyyDmJ~AmUc%Z*lp$ zuoW_&k%7+V#5qnE9-*syxhn(iU7+G-gO8K3_J_8|Ujp?5P9F0c^kZMNo@6s+OSl)k zbi-gL^6krBU4&%Ps`%~xQldX2NzP4Aca?F9kXe7j)Au>?I3ybi=jSH6;v;75i={zh zKCLaEXC2L%q%P6soaz5)^ktn7b3dNofS*f4kDgGZHq6XumjIYcDTaykx*+Ya&Wq3m z(cvSD=&eQ)QklvKEZkCHa^@;tqs30q4nD|TdG1I=SU6NtCne>zA=JQ0n6A!$4n}M! zMabIkmHYEGLQqw?*qkZd^UCQl{pHcwK#0RmmKqx>e67C+{3bF&h>8Xn) zZrDi>w))@$n~Ahb8@B1N2M+M{9Kk%+QTV0FVs&vZ{vBxvh)tsZ0_sB?zCqGuZR8Ua zg#C>jb=0AQ0Id?4!H?zL`BHj-gwdPV(R)Zxa^CjtxgIbg42tvp@#DuV?=ERRrraMS zLTgsgk-$Cz>BBd7F0~UbbuTk31Mq9%nzVS{0-{M zl?9MuGm9bsK8wxX6!}{EKg~sFoyMC23&&jKei?96io(NW$rTF9xebc!+I90xGK@{~ zpFP@C6!>u{gG<6p5+uN%D=3RK!NrntS`o2vSos{9e3<>B6Q(E zu5eSXwNr(P-AMUu^)Ei0aF`sqHTOM?VNK#)5b$|%q!d zW(L4mTAylscq=JAY21}X=@-;#5Y{y8kl-0fY5dKGORC!ukK}VGP(mJv|)*NhX(wJsqK7ueU7Y920yNPyfF< zzfRe_-k!3Zx+J0_)N6c|V^S@-|AU-W;T)OFMO3TlV37Lj1F0CKzTc=@fLc5NrmsUL z+2A8yRKNB5-+>awd@ec;dNiyRgudZlo~Zu!jxb%)xat85w=OHUPDb>8|K|+<-PS=* zwDUi!{^z94&Hf&zE0JNs3P?9&C^%M{Vgi5!1C2F5{Z#D|_woL*AzF+`Ul&OGUo7}y z<~&*os{VIa2-86+ENdwK5yrR2P%V8KF0E{%kLnI>IqIc1yW2L9J~@dKk44ofy`glX(f`u%tWsIx;Y9 z?C1WI$O_~$2l#}z{{R1f`4MT5M$Q6{$YKTtzQZ8Qcszea3Q$nn)5S5Q;?~=PhKxYo lp#@+4b2