studiorailgun/Renderer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Massive mesh refactor

Browse Source
This commit is contained in:
austin 2024-03-09 20:05:47 -05:00
parent 027c93d4c7
commit 76875cb8cb
54 changed files with 1454 additions and 1610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
buildNumber.properties
View File

@ -1,3 +1,3 @@
#maven.buildNumber.plugin properties file
#Sat Mar 09 15:31:50 EST 2024
buildNumber=34
#Sat Mar 09 19:55:08 EST 2024
buildNumber=35

2
src/main/java/electrosphere/client/fluid/cells/FluidDrawCell.java
View File

@ -11,7 +11,7 @@ import electrosphere.entity.ClientEntityUtils;
import electrosphere.entity.Entity;
import electrosphere.entity.EntityUtils;
import electrosphere.entity.types.fluid.FluidChunk;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
/**

2
src/main/java/electrosphere/client/fluid/cells/FluidDrawCellManager.java
View File

@ -13,7 +13,7 @@ import electrosphere.client.terrain.manager.ClientTerrainManager;
import electrosphere.engine.Globals;
import electrosphere.entity.EntityUtils;
import electrosphere.net.parser.net.message.TerrainMessage;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.shader.ShaderProgram;
/**
*

2
src/main/java/electrosphere/client/fluid/manager/ClientFluidManager.java
View File

@ -17,8 +17,8 @@ import electrosphere.engine.Globals;
import electrosphere.entity.types.fluid.FluidChunkModelData;
import electrosphere.logger.LoggerInterface;
import electrosphere.net.parser.net.message.TerrainMessage;
import electrosphere.renderer.Model;
import electrosphere.renderer.meshgen.FluidChunkModelGeneration;
import electrosphere.renderer.model.Model;
import electrosphere.server.terrain.manager.ServerTerrainManager;
/**

2
src/main/java/electrosphere/client/terrain/cells/DrawCell.java
View File

@ -11,7 +11,7 @@ import electrosphere.entity.ClientEntityUtils;
import electrosphere.entity.Entity;
import electrosphere.entity.EntityUtils;
import electrosphere.entity.types.terrain.TerrainChunk;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import electrosphere.server.datacell.Realm;

2
src/main/java/electrosphere/client/terrain/cells/DrawCellManager.java
View File

@ -13,7 +13,7 @@ import electrosphere.client.terrain.manager.ClientTerrainManager;
import electrosphere.engine.Globals;
import electrosphere.entity.EntityUtils;
import electrosphere.net.parser.net.message.TerrainMessage;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.shader.ShaderProgram;
/**
*

2
src/main/java/electrosphere/client/terrain/manager/ClientTerrainManager.java
View File

@ -19,8 +19,8 @@ import electrosphere.engine.Globals;
import electrosphere.entity.types.terrain.TerrainChunkData;
import electrosphere.logger.LoggerInterface;
import electrosphere.net.parser.net.message.TerrainMessage;
import electrosphere.renderer.Model;
import electrosphere.renderer.meshgen.TerrainChunkModelGeneration;
import electrosphere.renderer.model.Model;
import electrosphere.server.terrain.manager.ServerTerrainManager;
/**

6
src/main/java/electrosphere/engine/Globals.java
View File

@ -46,16 +46,16 @@ import electrosphere.net.server.player.Player;
import electrosphere.net.server.player.PlayerManager;
import electrosphere.net.synchronization.ClientSynchronizationManager;
import electrosphere.net.synchronization.EntityValueTrackingService;
import electrosphere.renderer.Material;
import electrosphere.renderer.RenderUtils;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.actor.instance.InstanceManager;
import electrosphere.renderer.light.PointLight;
import electrosphere.renderer.light.SpotLight;
import electrosphere.renderer.loading.ModelPretransforms;
import electrosphere.renderer.meshgen.TerrainChunkModelGeneration;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.shader.ShaderOptionMap;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.TextureMap;
import electrosphere.renderer.ui.ElementManager;
import electrosphere.renderer.ui.elements.ImagePanel;
@ -473,8 +473,6 @@ public class Globals {
//init fluid shader program
terrainShaderProgram = ShaderProgram.loadSpecificShader("/Shaders/fluid1/fluid1.vs", "/Shaders/fluid1/fluid1.fs");
TerrainChunkModelGeneration.terrainChunkShaderProgram = ShaderProgram.loadSpecificShader("/Shaders/fluid1/fluid1.vs", "/Shaders/fluid1/fluid1.fs");
//init skybox
assetManager.registerModelToSpecificString(RenderUtils.createSkyboxModel(null), AssetDataStrings.ASSET_STRING_SKYBOX_BASIC);
//init models
assetManager.addModelPathToQueue("Models/unitsphere.fbx");
assetManager.addModelPathToQueue("Models/unitsphere_1.fbx");

10
src/main/java/electrosphere/engine/assetmanager/AssetManager.java
View File

@ -5,13 +5,13 @@ import electrosphere.collision.CollisionBodyCreation;
import electrosphere.collision.CollisionEngine;
import electrosphere.collision.PhysicsUtils;
import electrosphere.collision.collidable.Collidable;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.actor.ActorShaderMask;
import electrosphere.renderer.buffer.HomogenousInstancedArray;
import electrosphere.renderer.buffer.HomogenousUniformBuffer;
import electrosphere.renderer.loading.ModelLoader;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import electrosphere.server.poseactor.PoseModel;
@ -188,8 +188,8 @@ public class AssetManager {
Model model = null;
if((model = fetchModel(shaderOverride.modelName)) != null){
for(Mesh mesh : model.meshes){
if(mesh.nodeID.equals(shaderOverride.getMeshName())){
mesh.shader = ShaderProgram.loadSpecificShader(shaderOverride.vertPath, shaderOverride.fragPath);
if(mesh.getMeshName().equals(shaderOverride.getMeshName())){
mesh.setShader(ShaderProgram.loadSpecificShader(shaderOverride.vertPath, shaderOverride.fragPath));
}
}
toRemove.add(shaderOverride);

2
src/main/java/electrosphere/entity/EntityUtils.java
View File

@ -10,9 +10,9 @@ import electrosphere.entity.state.movement.GroundMovementTree;
import electrosphere.entity.types.collision.CollisionObjUtils;
import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.entity.types.item.ItemUtils;
import electrosphere.renderer.Model;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.actor.ActorUtils;
import electrosphere.renderer.model.Model;
import electrosphere.server.datacell.Realm;
import electrosphere.server.datacell.ServerDataCell;
import electrosphere.server.datacell.utils.DataCellSearchUtils;

2
src/main/java/electrosphere/entity/state/movement/GroundMovementTree.java
View File

@ -20,8 +20,8 @@ import electrosphere.entity.state.movement.SprintTree.SprintTreeState;
import electrosphere.net.NetUtils;
import electrosphere.net.parser.net.message.EntityMessage;
import electrosphere.renderer.anim.Animation;
import electrosphere.renderer.model.Model;
import electrosphere.server.datacell.utils.DataCellSearchUtils;
import electrosphere.renderer.Model;
import electrosphere.renderer.actor.Actor;
import java.util.LinkedList;

2
src/main/java/electrosphere/entity/state/movement/ServerGroundMovementTree.java
View File

@ -19,9 +19,9 @@ import electrosphere.entity.state.movement.ServerSprintTree.SprintTreeState;
import electrosphere.net.NetUtils;
import electrosphere.net.parser.net.message.EntityMessage;
import electrosphere.renderer.anim.Animation;
import electrosphere.renderer.model.Model;
import electrosphere.server.datacell.utils.DataCellSearchUtils;
import electrosphere.server.poseactor.PoseActor;
import electrosphere.renderer.Model;
import electrosphere.renderer.actor.Actor;
import java.util.LinkedList;

2
src/main/java/electrosphere/entity/types/attach/AttachUtils.java
View File

@ -6,8 +6,8 @@ import electrosphere.entity.EntityDataStrings;
import electrosphere.entity.EntityTags;
import electrosphere.entity.EntityUtils;
import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.renderer.Model;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.model.Model;
import electrosphere.server.datacell.ServerDataCell;
import electrosphere.server.datacell.utils.ServerEntityTagUtils;

2
src/main/java/electrosphere/menu/MenuGenerators.java
View File

@ -17,11 +17,11 @@ import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.game.data.creature.type.CreatureType;
import electrosphere.game.data.creature.type.visualattribute.VisualAttribute;
import electrosphere.net.NetUtils;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.actor.ActorStaticMorph;
import electrosphere.renderer.actor.ActorUtils;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.ClickableElement;
import electrosphere.renderer.ui.Element;
import electrosphere.renderer.ui.NavigableElement.NavigationEventCallback;

2
src/main/java/electrosphere/menu/MenuGeneratorsInGame.java
View File

@ -11,10 +11,10 @@ import electrosphere.entity.EntityUtils;
import electrosphere.entity.types.creature.CreatureUtils;
import electrosphere.game.data.creature.type.CreatureType;
import electrosphere.game.data.creature.type.visualattribute.VisualAttribute;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.actor.ActorStaticMorph;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.ClickableElement;
import electrosphere.renderer.ui.Window;
import electrosphere.renderer.ui.NavigableElement.NavigationEventCallback;

2
src/main/java/electrosphere/menu/MenuGeneratorsMultiplayer.java
View File

@ -13,13 +13,13 @@ import electrosphere.game.data.creature.type.CreatureType;
import electrosphere.game.data.creature.type.visualattribute.AttributeVariant;
import electrosphere.game.data.creature.type.visualattribute.VisualAttribute;
import electrosphere.net.parser.net.message.CharacterMessage;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.actor.ActorStaticMorph;
import electrosphere.renderer.actor.ActorUtils;
import electrosphere.renderer.actor.ActorStaticMorph.StaticMorphTransforms;
import electrosphere.renderer.anim.Animation;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.ClickableElement;
import electrosphere.renderer.ui.Element;
import electrosphere.renderer.ui.ValueElement.ValueChangeEventCallback;

40
src/main/java/electrosphere/renderer/Camera.java
View File

@ -1,40 +0,0 @@
package electrosphere.renderer;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import org.joml.Vector3f;
/**
*
* @author satellite
*/
@Deprecated
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;
}
}

779
src/main/java/electrosphere/renderer/Mesh.java
View File

@ -1,779 +0,0 @@
package electrosphere.renderer;
import electrosphere.engine.Globals;
import electrosphere.engine.Main;
import electrosphere.entity.types.camera.CameraEntityUtils;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.RenderPipelineState.SelectedShaderEnum;
import electrosphere.renderer.actor.ActorTextureMask;
import electrosphere.renderer.actor.instance.InstanceData;
import electrosphere.renderer.buffer.HomogenousInstancedArray;
import electrosphere.renderer.buffer.HomogenousUniformBuffer;
import electrosphere.renderer.buffer.ShaderAttribute;
import electrosphere.renderer.buffer.HomogenousUniformBuffer.HomogenousBufferTypes;
import electrosphere.renderer.light.LightManager;
import electrosphere.renderer.loading.ModelPretransforms;
import electrosphere.renderer.texture.Texture;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.joml.Matrix4d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import org.joml.Sphered;
import org.joml.Vector3d;
import org.joml.Vector3f;
import org.joml.Vector4d;
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 org.lwjgl.opengl.GL15C;
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;
import org.lwjgl.opengl.GL40;
import org.lwjgl.opengl.GL45;
/**
*
* @author satellite
*/
public class Mesh {
//THIS IS NOT GUARANTEED TO BE THE PARENT MODEL THAT THIS WAS LOADED IN
//THIS CAN BE POST-LOAD SET IN MODEL VIA MODELMASK BEHAVIOR
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;
//THIS IS NOT GUARANTEED TO BE THE PARENT MODEL THAT THIS WAS LOADED IN
//THIS CAN BE POST-LOAD SET IN MODEL VIA MODELMASK BEHAVIOR
public ArrayList<Bone> bones = new ArrayList<Bone>();
public ArrayList<String> bone_id_list = new ArrayList<String>();
HashMap<String,Object> uniforms = new HashMap<String,Object>();
int bone_map_size = 0;
boolean hasBones = true;
public boolean hasTextureCoords = true;
public ActorTextureMask textureMask;
public float vertexMinX;
public float vertexMaxX;
public float vertexMinY;
public float vertexMaxY;
public float vertexMinZ;
public float vertexMaxZ;
public ShaderProgram shader;
ShaderProgram oitShader;
int shaderBoneArrayLocation;
Material material;
//the bounding sphere for this mesh
Sphered boundingSphere;
public static Mesh create_mesh_from_aimesh(AIMesh mesh, ModelPretransforms.MeshMetadata metadata){
boolean has_bones = false;
boolean apply_lighting = true;
Mesh rVal = new Mesh();
rVal.mesh = mesh;
rVal.nodeID = mesh.mName().dataString();
//
// VAO
//
//Check for headless to not call gl functions when not running with gpu
if(!Globals.HEADLESS){
rVal.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(rVal.vertexArrayObject);
}
//Basic checks
//check num vertices
int numVertices = mesh.mNumVertices();
AIVector3D.Buffer vertexData = mesh.mVertices();
// while(vertexData.hasRemaining()){
// vertexData.get();
// numVertices++;
// }
// vertexData = vertexData.rewind();
//check num normals
int numNormals = mesh.mNumVertices();
// AIVector3D.Buffer normalData = mesh.mNormals();
// while(normalData.hasRemaining()){
// normalData.get();
// numNormals++;
// }
// normalData.rewind();
if(numVertices != numNormals){
LoggerInterface.loggerNetworking.ERROR("Catastrophic failure: Number of vertices =/= Number of normals", new Exception("Catastrophic failure: Number of vertices =/= Number of normals"));
}
Matrix4d vertexPretransform = new Matrix4d().identity();
if(metadata != null){
LoggerInterface.loggerRenderer.DEBUG("Pretransforming");
vertexPretransform.translationRotateScale(metadata.getOffset(), metadata.getRotation(), metadata.getScale());
}
//
//Buffer data to GPU
//
vertexData.rewind();
try {
rVal.vertexCount = mesh.mNumVertices();
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(rVal.vertexCount * 3);
float[] temp = new float[3];
boolean definedDimensions = false;
float minX = 0, maxX = 0, minY = 0, maxY = 0, minZ = 0, maxZ = 0;
for (int i = 0; i < rVal.vertexCount; i++) {
AIVector3D vertex = vertexData.get();
float x = vertex.x();
float y = vertex.y();
float z = vertex.z();
//store dimensions of the model
if(definedDimensions){
if(x < minX){ minX = x; }
if(x > maxX){ maxX = x; }
if(y < minY){ minY = y; }
if(y > maxY){ maxY = y; }
if(z < minZ){ minZ = z; }
if(z > maxZ){ maxZ = z; }
} else {
definedDimensions = true;
minX = maxX = x;
minY = maxY = y;
minZ = maxZ = z;
}
//update bounding sphere
double dist = Math.sqrt(x*x+y*y+z*z);
if(dist > rVal.boundingSphere.r){
rVal.boundingSphere.r = dist;
}
//store vertex data
Vector4d transformedVertex = vertexPretransform.transform(new Vector4d(x,y,z,1.0));
transformedVertex.w = 1.0;
temp[0] = (float)transformedVertex.x;
temp[1] = (float)transformedVertex.y;
temp[2] = (float)transformedVertex.z;
VertexArrayBufferData.put(temp);
}
rVal.vertexMaxX = maxX;
rVal.vertexMinX = minX;
rVal.vertexMaxY = maxY;
rVal.vertexMinY = minY;
rVal.vertexMaxZ = maxZ;
rVal.vertexMinZ = minZ;
VertexArrayBufferData.flip();
rVal.buffer_vertices(VertexArrayBufferData, 3);
} 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, 3);
}
} 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, 2);
}
} 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 = electrosphere.util.Utilities.convertAIMatrixd(currentBoneData.mOffsetMatrix());
currentBone.numWeights = currentBoneData.mNumWeights();
currentBone.weights = new HashMap<Integer,Float>();
Iterator<AIVertexWeight> 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<Bone> 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;
// if(rVal.nodeID.equals("Torso")){
// System.out.println(index[3] + " " + index[2] + " " + index[1] + " " + index[0]);
// }
} 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);
}
//If all are 0 (for instance the vertex doesn't have any bones with any weight > 0), the values for each weight will be NaN after the divide immediately above
//If NaN, set all to 0
if(Float.isNaN(weight[0])){
weight[0] = 0;
weight[1] = 0;
weight[2] = 0;
weight[3] = 0;
}
boneIndexDataBuffer.put(index);
boneWeightDataBuffer.put(weight);
}
boneIndexDataBuffer.flip();
boneWeightDataBuffer.flip();
if(!Globals.HEADLESS){
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;
}
if(!Globals.HEADLESS){
rVal.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting);
rVal.oitShader = ShaderProgram.smartAssembleOITProgram(has_bones, apply_lighting);
}
if(!Globals.HEADLESS){
glBindVertexArray(0);
}
return rVal;
}
public Mesh(){
this.boundingSphere = new Sphered();
}
public void buffer_vertices(FloatBuffer verticies, int vertexDimension){
if(!Globals.HEADLESS){
vertexBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, verticies, GL_STATIC_DRAW);
glVertexAttribPointer(0, vertexDimension, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(0);
}
}
public void buffer_normals(FloatBuffer normals, int normalDimension){
if(!Globals.HEADLESS){
normalBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, normals, GL_STATIC_DRAW);
glVertexAttribPointer(1, normalDimension, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(1);
}
}
public void buffer_faces(IntBuffer faces){
if(!Globals.HEADLESS){
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, int textureDimension){
if(!Globals.HEADLESS){
textureCoordBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, textureCoordBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, coords, GL_STATIC_DRAW);
glVertexAttribPointer(4, textureDimension, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(4);
}
}
public void bufferCustomFloatAttribArray(FloatBuffer buffer, int bufferDimension, int attribIndex){
if(!Globals.HEADLESS){
int customBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, customBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
}
public void bufferCustomIntAttribArray(IntBuffer buffer, int bufferDimension, int attribIndex){
if(!Globals.HEADLESS){
int customBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, customBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_INT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
}
public void bufferCustomUIntAttribArray(IntBuffer buffer, int bufferDimension, int attribIndex){
if(!Globals.HEADLESS){
int customBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, customBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_UNSIGNED_INT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
}
public void setTextureMask(ActorTextureMask textureMask){
this.textureMask = textureMask;
}
public void setMaterial(Material input){
this.material = input;
}
public void generateShader(SelectedShaderEnum selectedShader, boolean hasBones, boolean applyLighting){
switch(selectedShader){
case PRIMARY: {
shader = ShaderProgram.smart_assemble_shader(hasBones, applyLighting);
} break;
case OIT: {
oitShader = ShaderProgram.smartAssembleOITProgram(hasBones, applyLighting);
} break;
}
}
public void setShader(ShaderProgram shader){
this.shader = shader;
}
public void setUniform(String key, Object o){
uniforms.put(key, o);
}
void bufferAllUniforms(){
for(String key : uniforms.keySet()){
Object currentUniformRaw = uniforms.get(key);
if(currentUniformRaw instanceof Matrix4f){
Matrix4f currentUniform = (Matrix4f)currentUniformRaw;
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, key), false, currentUniform.get(new float[16]));
}
if(currentUniformRaw instanceof Vector3f){
Vector3f currentUniform = (Vector3f)currentUniformRaw;
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, key), currentUniform.get(BufferUtils.createFloatBuffer(3)));
}
if(currentUniformRaw instanceof Integer){
int currentInform = (Integer)currentUniformRaw;
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, key), currentInform);
}
}
}
/**
* Sends a buffer to the gpu
* @param uniformTypeMap The type of the buffer
* @param buffers The buffer
*/
void bufferInstanceData(
RenderPipelineState renderPipelineState,
Map<ShaderAttribute,Object> buffers,
Map<ShaderAttribute,HomogenousInstancedArray> uniformGlBufferMap
){
for(ShaderAttribute attribute : buffers.keySet()){
HomogenousInstancedArray buffer = uniformGlBufferMap.get(attribute);
buffer.updateBuffer(buffers.get(attribute), 0);
buffer.bind(renderPipelineState);
}
}
/**
* Draws the mesh
* @param renderPipelineState The state of the render pipeline
*/
public void complexDraw(RenderPipelineState renderPipelineState){
if(renderPipelineState.getUseMeshShader()){
ShaderProgram selectedProgram = null;
switch(renderPipelineState.getSelectedShader()){
case PRIMARY: {
selectedProgram = shader;
} break;
case OIT: {
selectedProgram = oitShader;
} break;
}
if(selectedProgram == null){
selectedProgram = shader;
}
Globals.renderingEngine.setActiveShader(renderPipelineState, selectedProgram);
}
if(renderPipelineState.getUseLight()){
//Until we switch to uniform buffer objects we will have to buffer lighting data here manually each time we draw
//side note: :(
if(Globals.renderingEngine.getLightManager() == null){
//don't buffer as the light manager hasn't initialized
} else {
LightManager lightManager = Globals.renderingEngine.getLightManager();
lightManager.bindBuffer(Globals.renderingEngine.getActiveShader().shaderProgram);
}
}
if(renderPipelineState.getUseMaterial() && textureMask == null){
if(material == null){
Globals.materialDefault.apply_material(0,1);
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasTransparency"), 0);
} else {
material.apply_material();
if(material.hasTransparency){
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasTransparency"), 1);
} else {
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasTransparency"), 0);
}
}
}
glBindVertexArray(vertexArrayObject);
if(textureMask != null){
int i = 0;
// glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "groundTextures"), 5);
// for(int j = 1; j < 15; j++){
// textureList.get(0).bind(j);
// }
for(Texture texture : textureMask.getTextures()){
// System.out.println(texture.getPath() + " => groundTextures[" + i + "]" + "=>" + (i));
if(texture != null){
texture.bind(5+i);
}
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, textureMask.getUniformNames().get(i)),5+i);
i++;
}
// for(int j = i; j < 10; j++){
// glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "groundTextures[" + j + "]"),6+j);
// }
// glActiveTexture(GL_TEXTURE0);
}
if(renderPipelineState.getUseShadowMap()){
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, Globals.shadowMapTextureLoc);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "shadowMap"), 3);
}
if(renderPipelineState.getUseBones()){
//
//Handle bones
//
if(bones != null && !bones.isEmpty()){
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasBones"), 1);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "numBones"), bones.size());
Iterator<String> boneIterator = bone_id_list.iterator();
float bufferarray[] = new float[16];
int incrementer = 0;
while (boneIterator.hasNext()){
String boneName = boneIterator.next();
Bone currentBone = parent.boneMap.get(boneName);
String currentUniform = "bones[" + incrementer + "]";
if(currentBone != null){
Matrix4d currentMat = new Matrix4d(currentBone.final_transform);
currentMat.get(bufferarray);
// if(boneName.equals("Torso")){
// System.out.println("Found torso bone");
// System.out.println(currentUniform);
// System.out.println(currentMat);
// }
GL45.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, currentUniform), false, bufferarray);
} else {
// System.out.println("Bonename: " + boneName);
// System.exit(1);
GL45.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, currentUniform), false, new float[16]);
}
incrementer++;
}
} else {
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasBones"), 0);
}
} else {
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "hasBones"), 0);
}
if(renderPipelineState.getBufferStandardUniforms()){
//buffer model/view/proj matrices
GL45.glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16]));
glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexViewLoc, false, Globals.viewMatrix.get(new float[16]));
glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16]));
glUniform3fv(Globals.renderingEngine.getActiveShader().shaderVertexViewPosLoc, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "frame"), (int)Globals.timekeeper.getNumberOfRenderFramesElapsed());
glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "time"), (float)Globals.timekeeper.getCurrentRendererTime());
}
if(renderPipelineState.getBufferNonStandardUniforms()){
bufferAllUniforms();
}
if(renderPipelineState.getInstanced()){
InstanceData instanceData = renderPipelineState.getInstanceData();
Map<ShaderAttribute,Object> buffers = instanceData.getCpuBufferMap();
Map<ShaderAttribute,HomogenousInstancedArray> glBufferMap = instanceData.getGlBufferMap();
bufferInstanceData(renderPipelineState, buffers, glBufferMap);
}
if(renderPipelineState.getInstanced()){
GL45.glDrawElementsInstanced(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0, renderPipelineState.getInstanceData().getDrawCount());
} else {
GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
}
glBindVertexArray(0);
}
/**
* Updates the bounding sphere of the mesh
* @param x
* @param y
* @param z
* @param r
*/
public void updateBoundingSphere(float x, float y, float z, float r){
this.boundingSphere.x = x;
this.boundingSphere.y = y;
this.boundingSphere.z = z;
this.boundingSphere.r = r;
}
/**
* Gets the bounding sphere of this mesh
* @return The bounding sphere
*/
public Sphered getBoundingSphere(){
return this.boundingSphere;
}
}

210
src/main/java/electrosphere/renderer/ModelUtils.java
View File

@ -1,210 +0,0 @@
package electrosphere.renderer;
import electrosphere.engine.Globals;
import electrosphere.engine.assetmanager.AssetDataStrings;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.texture.Texture;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import org.joml.Vector3f;
import org.lwjgl.BufferUtils;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;
/**
*
* @author satellite
*/
public class ModelUtils {
// public static Model createTerrainModel(float[][] heightfield, int stride){
// Model rVal = new Model();
// rVal.meshes = new ArrayList();
// Mesh m = new Mesh();
// int width = heightfield.length;
// int height = heightfield[0].length;
//
// int actualWidth = (int)Math.ceil(1.0 * width / stride);
// int actualHeight = (int)Math.ceil(1.0 * height / stride);
//
//// System.out.println(actualWidth + " " + actualHeight);
//
//// System.out.println((actualWidth - 1) * (actualHeight - 1));
//
// FloatBuffer vertices = BufferUtils.createFloatBuffer(actualWidth * actualHeight * 3);
// FloatBuffer normals = BufferUtils.createFloatBuffer(actualWidth * actualHeight * 3);
// IntBuffer faces = BufferUtils.createIntBuffer((actualWidth - 1) * (actualHeight - 1) * 2 * 3);
// FloatBuffer texture_coords = BufferUtils.createFloatBuffer(actualWidth * actualHeight * 2);
// for(int x = 0; x < width; x = x + stride){
// for(int y = 0; y < height; y = y + stride){
// //deal with vertex
// vertices.put(x);
// vertices.put(heightfield[x][y]);
// vertices.put(y);
// //deal with normal
// if(x / stride < actualWidth - 1){
// if(y / stride < actualHeight - 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 / stride < actualHeight - 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 / stride % 2 == 0){
// if(y / stride % 2 == 0){
// texture_coords.put(0);
// texture_coords.put(0);
// } else {
// texture_coords.put(0);
// texture_coords.put(1);
// }
// } else {
// if(y / stride % 2 == 0){
// texture_coords.put(1);
// texture_coords.put(0);
// } else {
// texture_coords.put(1);
// texture_coords.put(1);
// }
// }
// //deal with faces
// if(x / stride < actualWidth - 1 && y / stride < actualHeight - 1){
// faces.put((x / stride + 0) * actualHeight + (y / stride + 0));
// faces.put((x / stride + 0) * actualHeight + (y / stride + 1));
// faces.put((x / stride + 1) * actualHeight + (y / stride + 0));
// faces.put((x / stride + 1) * actualHeight + (y / stride + 0));
// faces.put((x / stride + 0) * actualHeight + (y / stride + 1));
// faces.put((x / stride + 1) * actualHeight + (y / stride + 1));
// }
// }
// }
// vertices.flip();
// normals.flip();
// faces.flip();
// texture_coords.flip();
//
// m.vertexArrayObject = glGenVertexArrays();
// glBindVertexArray(m.vertexArrayObject);
// //buffer vertices
// m.buffer_vertices(vertices, 3);
// //buffer normals
// m.buffer_normals(normals, 3);
// //buffer faces
// m.buffer_faces(faces);
// //buffer texture coords
// m.buffer_texture_coords(texture_coords, 2);
// m.shader = ShaderProgram.loadSpecificShader("/Shaders/terrain/terrain.vs", "/Shaders/terrain/terrain.fs");
// glBindVertexArray(0);
// m.parent = rVal;
//
// Material groundMat = new Material();
// Globals.assetManager.addTexturePathtoQueue("/Textures/Ground/Dirt1.png");
// groundMat.set_diffuse("/Textures/Ground/Dirt1.png");
// groundMat.set_specular("/Textures/Ground/Dirt1.png");
// m.set_material(groundMat);
//
// rVal.meshes.add(m);
// return rVal;
// }
public static void printModelDimension(Model m){
float minX = 0;
float maxX = 0;
float minY = 0;
float maxY = 0;
float minZ = 0;
float maxZ = 0;
boolean initiated = false;
for(Mesh currentMesh : m.meshes){
if(initiated){
if(currentMesh.vertexMinX < minX){ minX = currentMesh.vertexMinX; }
if(currentMesh.vertexMaxX > maxX){ maxX = currentMesh.vertexMaxX; }
if(currentMesh.vertexMinY < minY){ minY = currentMesh.vertexMinY; }
if(currentMesh.vertexMaxY > maxY){ maxY = currentMesh.vertexMaxY; }
if(currentMesh.vertexMinZ < minZ){ minZ = currentMesh.vertexMinZ; }
if(currentMesh.vertexMaxZ > maxZ){ maxZ = currentMesh.vertexMaxZ; }
} else {
initiated = true;
minX = currentMesh.vertexMinX;
maxX = currentMesh.vertexMaxX;
minY = currentMesh.vertexMinY;
maxY = currentMesh.vertexMaxY;
minZ = currentMesh.vertexMinZ;
maxZ = currentMesh.vertexMaxZ;
}
}
LoggerInterface.loggerRenderer.INFO("dimensions: " + (maxX - minX) + "," + (maxY - minY) + "," + (maxZ-minZ));
}
}

421
src/main/java/electrosphere/renderer/RenderUtils.java
View File

@ -12,6 +12,10 @@ import java.util.LinkedList;
import java.util.List;
import electrosphere.renderer.actor.ActorTextureMask;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import org.joml.Matrix4d;
@ -136,246 +140,6 @@ public class RenderUtils {
public static Model createSkyboxModel(Material optionalMaterial){
Model skyboxModel = new Model();
skyboxModel.meshes = new ArrayList<Mesh>();
skyboxModel.modelMatrix = new Matrix4d();
// boolean apply_lighting = false;
// boolean has_bones = false;
Mesh skyboxmesh = new Mesh(){
@Override
public void complexDraw(RenderPipelineState renderPipelineState){
if(renderPipelineState.getUseMeshShader()){
GL11.glDepthFunc(GL_LEQUAL);
glUseProgram(shader.shaderProgram);
}
if(renderPipelineState.getUseMaterial()){
if(material == null){
Globals.materialDefault.apply_material(0,1);
Iterator<Vector3f> colorIterator = Globals.skyboxColors.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);
if(renderPipelineState.getBufferStandardUniforms()){
//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, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
}
GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
if(renderPipelineState.getUseMeshShader()){
GL11.glDepthFunc(GL_LESS);
}
}
};
skyboxmesh.mesh = null;
//
// VAO
//
skyboxmesh.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(skyboxmesh.vertexArrayObject);
float[] vertexcoords = {
100.0f, 100.0f, 100.0f,
100.0f, 100.0f,-100.0f,
100.0f,-100.0f, 100.0f,
100.0f,-100.0f,-100.0f,
-100.0f, 100.0f, 100.0f,
-100.0f, 100.0f,-100.0f,
-100.0f,-100.0f, 100.0f,
-100.0f,-100.0f,-100.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, 3);
} 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, 3);
}
} 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 = skyboxModel;
skyboxModel.meshes.add(skyboxmesh);
return skyboxModel;
}
public static Model createParticleModel(){
@ -384,16 +148,13 @@ public class RenderUtils {
particleModel.modelMatrix = new Matrix4d();
Mesh particleMesh = new Mesh();
Mesh particleMesh = new Mesh("particleBillboard");
particleMesh.mesh = null;
//
// VAO
//
particleMesh.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(particleMesh.vertexArrayObject);
particleMesh.generateVAO();
@ -417,17 +178,17 @@ public class RenderUtils {
//
try {
particleMesh.vertexCount = vertexcoords.length / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(particleMesh.vertexCount * 3);
int vertexCount = vertexcoords.length / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(vertexCount * 3);
float[] temp = new float[3];
for (int i = 0; i < particleMesh.vertexCount; i++) {
for (int i = 0; i < 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();
particleMesh.buffer_vertices(VertexArrayBufferData, 3);
particleMesh.bufferVertices(VertexArrayBufferData, 3);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -440,10 +201,10 @@ public class RenderUtils {
//
// FACES
//
particleMesh.faceCount = facedata.length / 3;
particleMesh.elementCount = facedata.length;
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(particleMesh.elementCount);
for(int i = 0; i < particleMesh.faceCount; i++){
int faceCount = facedata.length / 3;
int elementCount = facedata.length;
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(elementCount);
for(int i = 0; i < faceCount; i++){
int[] temp = new int[3];
temp[0] = facedata[i * 3 + 0];
temp[1] = facedata[i * 3 + 1];
@ -451,7 +212,7 @@ public class RenderUtils {
elementArrayBufferData.put(temp);
}
elementArrayBufferData.flip();
particleMesh.buffer_faces(elementArrayBufferData);
particleMesh.bufferFaces(elementArrayBufferData,elementCount);
//
// TEXTURE COORDS
@ -465,13 +226,12 @@ public class RenderUtils {
};
texture_coords.put(texturedata);
texture_coords.flip();
particleMesh.buffer_texture_coords(texture_coords, 2);
particleMesh.bufferTextureCoords(texture_coords, 2);
particleMesh.shader = ShaderProgram.loadSpecificShader("Shaders/particleBillboard/particleBillboard.vs", "Shaders/particleBillboard/particleBillboard.fs");
particleMesh.hasBones = false;
particleMesh.setShader(ShaderProgram.loadSpecificShader("Shaders/particleBillboard/particleBillboard.vs", "Shaders/particleBillboard/particleBillboard.fs"));
@ -486,9 +246,7 @@ public class RenderUtils {
particleMesh.nodeID = "particleBillboard";
particleMesh.parent = particleModel;
particleMesh.setParent(particleModel);
particleModel.meshes.add(particleMesh);
@ -505,16 +263,14 @@ public class RenderUtils {
rVal.modelMatrix = new Matrix4d();
Mesh planeMesh = new Mesh();
Mesh planeMesh = new Mesh("plane");
planeMesh.mesh = null;
//
// VAO
//
planeMesh.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(planeMesh.vertexArrayObject);
planeMesh.generateVAO();
@ -538,17 +294,17 @@ public class RenderUtils {
//
try {
planeMesh.vertexCount = vertexcoords.length / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(planeMesh.vertexCount * 3);
int vertexCount = vertexcoords.length / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(vertexCount * 3);
float[] temp = new float[3];
for (int i = 0; i < planeMesh.vertexCount; i++) {
for (int i = 0; i < 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();
planeMesh.buffer_vertices(VertexArrayBufferData, 3);
planeMesh.bufferVertices(VertexArrayBufferData, 3);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -561,10 +317,10 @@ public class RenderUtils {
//
// FACES
//
planeMesh.faceCount = facedata.length / 3;
planeMesh.elementCount = facedata.length;
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(planeMesh.elementCount);
for(int i = 0; i < planeMesh.faceCount; i++){
int faceCount = facedata.length / 3;
int elementCount = facedata.length;
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(elementCount);
for(int i = 0; i < faceCount; i++){
int[] temp = new int[3];
temp[0] = facedata[i * 3 + 0];
temp[1] = facedata[i * 3 + 1];
@ -572,7 +328,7 @@ public class RenderUtils {
elementArrayBufferData.put(temp);
}
elementArrayBufferData.flip();
planeMesh.buffer_faces(elementArrayBufferData);
planeMesh.bufferFaces(elementArrayBufferData,elementCount);
//
// TEXTURE COORDS
@ -586,13 +342,12 @@ public class RenderUtils {
};
texture_coords.put(texturedata);
texture_coords.flip();
planeMesh.buffer_texture_coords(texture_coords, 2);
planeMesh.bufferTextureCoords(texture_coords, 2);
planeMesh.shader = ShaderProgram.loadSpecificShader(vertexShader,fragmentShader);
planeMesh.hasBones = false;
planeMesh.setShader(ShaderProgram.loadSpecificShader(vertexShader,fragmentShader));
@ -607,9 +362,7 @@ public class RenderUtils {
planeMesh.nodeID = "plane";
planeMesh.parent = rVal;
planeMesh.setParent(rVal);
rVal.meshes.add(planeMesh);
@ -624,9 +377,8 @@ public class RenderUtils {
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
Mesh m = new Mesh(AssetDataStrings.ASSET_STRING_BITMAP_FONT_MESH_NAME);
m.generateVAO();
//vertices
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(12);
VertexArrayBufferData.put( 0);
@ -684,21 +436,20 @@ public class RenderUtils {
//buffer vertices
m.buffer_vertices(VertexArrayBufferData, 2);
m.bufferVertices(VertexArrayBufferData, 2);
//buffer normals
m.buffer_normals(VertexArrayBufferData, 2);
m.bufferNormals(VertexArrayBufferData, 2);
//buffer faces
m.buffer_faces(faceArrayBufferData);
m.bufferFaces(faceArrayBufferData, 2);
//buffer texture coords
m.buffer_texture_coords(TextureArrayBufferData, 2);
m.bufferTextureCoords(TextureArrayBufferData, 2);
m.shader = ShaderProgram.loadSpecificShader("/Shaders/font/basicbitmap/basicbitmap.vs", "/Shaders/font/basicbitmap/basicbitmap.fs");
m.setShader(ShaderProgram.loadSpecificShader("/Shaders/font/basicbitmap/basicbitmap.vs", "/Shaders/font/basicbitmap/basicbitmap.fs"));
glBindVertexArray(0);
m.parent = rVal;
m.nodeID = AssetDataStrings.ASSET_STRING_BITMAP_FONT_MESH_NAME;
m.setParent(rVal);
Material uiMat = new Material();
Globals.assetManager.addTexturePathtoQueue("/Textures/Fonts/myfont1-harsher.png");
@ -725,9 +476,8 @@ public class RenderUtils {
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
Mesh m = new Mesh(AssetDataStrings.ASSET_STRING_BITMAP_FONT_MESH_NAME);
m.generateVAO();
//vertices
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(12);
VertexArrayBufferData.put(-1);
@ -785,21 +535,20 @@ public class RenderUtils {
//buffer vertices
m.buffer_vertices(VertexArrayBufferData, 2);
m.bufferVertices(VertexArrayBufferData, 2);
//buffer normals
m.buffer_normals(VertexArrayBufferData, 2);
m.bufferNormals(VertexArrayBufferData, 2);
//buffer faces
m.buffer_faces(faceArrayBufferData);
m.bufferFaces(faceArrayBufferData, 6);
//buffer texture coords
m.buffer_texture_coords(TextureArrayBufferData, 2);
m.bufferTextureCoords(TextureArrayBufferData, 2);
m.shader = ShaderProgram.loadSpecificShader("/Shaders/font/bitmapchar/bitmapchar.vs", "/Shaders/font/bitmapchar/bitmapchar.fs");
m.setShader(ShaderProgram.loadSpecificShader("/Shaders/font/bitmapchar/bitmapchar.vs", "/Shaders/font/bitmapchar/bitmapchar.fs"));
glBindVertexArray(0);
m.parent = rVal;
m.nodeID = AssetDataStrings.ASSET_STRING_BITMAP_FONT_MESH_NAME;
m.setParent(rVal);
rVal.meshes.add(m);
@ -812,9 +561,8 @@ public class RenderUtils {
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
Mesh m = new Mesh("plane");
m.generateVAO();
//vertices
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(12);
VertexArrayBufferData.put(-1);
@ -872,21 +620,20 @@ public class RenderUtils {
//buffer vertices
m.buffer_vertices(VertexArrayBufferData, 2);
m.bufferVertices(VertexArrayBufferData, 2);
//buffer normals
m.buffer_normals(VertexArrayBufferData, 2);
m.bufferNormals(VertexArrayBufferData, 2);
//buffer faces
m.buffer_faces(faceArrayBufferData);
m.bufferFaces(faceArrayBufferData, 2);
//buffer texture coords
m.buffer_texture_coords(TextureArrayBufferData, 2);
m.bufferTextureCoords(TextureArrayBufferData, 2);
m.shader = ShaderProgram.loadSpecificShader(vertexShader, fragmentShader);
m.setShader(ShaderProgram.loadSpecificShader(vertexShader, fragmentShader));
glBindVertexArray(0);
m.parent = rVal;
m.nodeID = "plane";
m.setParent(rVal);
rVal.meshes.add(m);
@ -899,7 +646,7 @@ public class RenderUtils {
public static Model createTerrainModelPrecomputedShader(float[][] heightfield, float[][] texturemap, ShaderProgram program, int stride){
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
Mesh m = new Mesh("terrain");
int width = heightfield.length;
int height = heightfield[0].length;
@ -1044,23 +791,20 @@ public class RenderUtils {
texture_coords.flip();
textureIndices.flip();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
m.generateVAO();
//buffer vertices
m.buffer_vertices(vertices, 3);
m.bufferVertices(vertices, 3);
//buffer normals
m.buffer_normals(normals, 3);
m.bufferNormals(normals, 3);
//buffer faces
m.buffer_faces(faces);
m.bufferFaces(faces,incrementer*2);
//buffer texture coords
m.buffer_texture_coords(texture_coords, 2);
m.bufferTextureCoords(texture_coords, 2);
//texture indices
m.bufferCustomFloatAttribArray(textureIndices, 4, 5);
m.shader = program;
m.setShader(program);
glBindVertexArray(0);
m.parent = rVal;
m.hasBones = false;
m.setParent(rVal);
Material groundMat = new Material();
Globals.assetManager.addTexturePathtoQueue("/Textures/Ground/Dirt1.png");
@ -1106,8 +850,7 @@ public class RenderUtils {
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
m.nodeID = "terrain";
Mesh m = new Mesh("terrain");
int width = heightfield.length;
int height = heightfield[0].length;
@ -1609,23 +1352,20 @@ public class RenderUtils {
texture_coords.flip();
textureIndices.flip();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
m.generateVAO();
//buffer vertices
m.buffer_vertices(vertices, 3);
m.bufferVertices(vertices, 3);
//buffer normals
m.buffer_normals(normals, 3);
m.bufferNormals(normals, 3);
//buffer faces
m.buffer_faces(faces);
m.bufferFaces(faces,incrementer*2);
//buffer texture coords
m.buffer_texture_coords(texture_coords, 2);
m.bufferTextureCoords(texture_coords, 2);
//texture indices
m.bufferCustomFloatAttribArray(textureIndices, 4, 5);
m.shader = program;
m.setShader(program);
glBindVertexArray(0);
m.parent = rVal;
m.hasBones = false;
m.setParent(rVal);
Material groundMat = new Material();
Globals.assetManager.addTexturePathtoQueue("/Textures/Ground/Dirt1.png");
@ -1699,7 +1439,7 @@ public class RenderUtils {
public static Model createUnitCube(){
Model rVal = new Model();
rVal.meshes = new ArrayList<Mesh>();
Mesh m = new Mesh();
Mesh m = new Mesh("cube");
// System.out.println(actualWidth + " " + actualHeight);
@ -1839,19 +1579,18 @@ public class RenderUtils {
faces.flip();
texture_coords.flip();
m.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(m.vertexArrayObject);
m.generateVAO();
//buffer vertices
m.buffer_vertices(vertices, 3);
m.bufferVertices(vertices, 3);
//buffer normals
m.buffer_normals(normals, 3);
m.bufferNormals(normals, 3);
//buffer faces
m.buffer_faces(faces);
m.bufferFaces(faces,12);
//buffer texture coords
m.buffer_texture_coords(texture_coords, 2);
m.shader = ShaderProgram.smart_assemble_shader(false,true);
m.bufferTextureCoords(texture_coords, 2);
m.setShader(ShaderProgram.smart_assemble_shader(false,true));
glBindVertexArray(0);
m.parent = rVal;
m.setParent(rVal);
Material groundMat = new Material();
Globals.assetManager.addTexturePathtoQueue("/Textures/Ground/Dirt1.png");

30
src/main/java/electrosphere/renderer/RenderingEngine.java
View File

@ -99,6 +99,8 @@ import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.framebuffer.Renderbuffer;
import electrosphere.renderer.light.LightManager;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.Element;
@ -339,7 +341,7 @@ public class RenderingEngine {
//create light depth framebuffer/shader for shadowmapping
//
lightDepthShaderProgram = ShaderProgram.loadSpecificShader("/Shaders/lightDepth/lightDepth.vs", "/Shaders/lightDepth/lightDepth.fs");
Globals.depthMapShaderProgramLoc = lightDepthShaderProgram.shaderProgram;
Globals.depthMapShaderProgramLoc = lightDepthShaderProgram.getShaderId();
lightDepthBuffer = FramebufferUtils.generateDepthBuffer();
Globals.shadowMapTextureLoc = lightDepthBuffer.getTexturePointer();
// glEnable(GL_CULL_FACE); // enabled for shadow mapping
@ -600,7 +602,7 @@ public class RenderingEngine {
);
Globals.lightDepthMatrix = new Matrix4f(lightProjection).mul(lightView);
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
// glCullFace(GL_FRONT);
@ -1287,7 +1289,7 @@ public class RenderingEngine {
break;
case 7:
Globals.renderingEngine.setActiveShader(renderPipelineState, drawChannel);
glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "channel"),4);
glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "channel"),4);
glBindTexture(GL_TEXTURE_2D, screenTextureDepth.getTexturePointer());
break;
}
@ -1350,16 +1352,16 @@ public class RenderingEngine {
// glBindTexture(GL_TEXTURE_2D, woodTexture);
// renderScene(simpleDepthShader);
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "view"), false, Globals.viewMatrix.get(new float[16]));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "view"), false, Globals.viewMatrix.get(new float[16]));
// glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "projection"), false, Globals.projectionMatrix.get(new float[16]));
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "linearCoef"), volumeDepthLinearCoef);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "quadCoef"), volumeDepthQuadCoef);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "linearCoef"), volumeDepthLinearCoef);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "quadCoef"), volumeDepthQuadCoef);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "near"), 0.1f);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "far"), 100f);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "near"), 0.1f);
GL20.glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "far"), 100f);
// glCullFace(GL_FRONT);
@ -1395,7 +1397,7 @@ public class RenderingEngine {
// } else if(cameraModifiedPosition.length() > 0.5f){
// glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "projection"), false, midVolumeProjectionMatrix.get(new float[16]));
// } else {
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "projection"), false, nearVolumeProjectionMatrix.get(new float[16]));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "projection"), false, nearVolumeProjectionMatrix.get(new float[16]));
// }
// glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "projection"), false, Globals.projectionMatrix.get(new float[16]));
//calculate and apply model transform
@ -1427,7 +1429,7 @@ public class RenderingEngine {
//calculate camera-modified vector3f
Vector3f cameraModifiedPosition = new Vector3f((float)position.x,(float)position.y,(float)position.z).sub(CameraEntityUtils.getCameraCenter(Globals.playerCamera));
//set projection matrix
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "projection"), false, nearVolumeProjectionMatrix.get(new float[16]));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "projection"), false, nearVolumeProjectionMatrix.get(new float[16]));
modelTransformMatrix = modelTransformMatrix.identity();
modelTransformMatrix.translate(cameraModifiedPosition);
modelTransformMatrix.rotate(EntityUtils.getRotation(currentEntity));
@ -1502,7 +1504,7 @@ public class RenderingEngine {
static void renderBlackBackground(){
//render full screen quad
glUseProgram(screenTextureShaders.shaderProgram);
glUseProgram(screenTextureShaders.getShaderId());
glDisable(GL_DEPTH_TEST);
glBindVertexArray(screenTextureVAO);
Texture blackTexture = Globals.assetManager.fetchTexture(Globals.blackTexture);
@ -1516,7 +1518,7 @@ public class RenderingEngine {
static void renderWhiteBackground(){
//render full screen quad
glUseProgram(screenTextureShaders.shaderProgram);
glUseProgram(screenTextureShaders.getShaderId());
glDisable(GL_DEPTH_TEST);
glBindVertexArray(screenTextureVAO);
Texture blackTexture = Globals.assetManager.fetchTexture(Globals.offWhiteTexture);
@ -1534,9 +1536,9 @@ public class RenderingEngine {
* @param program The shader program to bind
*/
public void setActiveShader(RenderPipelineState renderPipelineState, ShaderProgram program){
glUseProgram(program.shaderProgram);
glUseProgram(program.getShaderId());
activeProgram = program;
renderPipelineState.setCurrentShaderPointer(program.shaderProgram);
renderPipelineState.setCurrentShaderPointer(program.getShaderId());
}
public ShaderProgram getActiveShader(){

4
src/main/java/electrosphere/renderer/actor/Actor.java
View File

@ -1,9 +1,9 @@
package electrosphere.renderer.actor;
import electrosphere.engine.Globals;
import electrosphere.renderer.Bone;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderPipelineState;
import electrosphere.renderer.model.Bone;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.texture.Texture;
import java.util.HashMap;

6
src/main/java/electrosphere/renderer/actor/ActorMeshMask.java
View File

@ -8,8 +8,8 @@ import java.util.concurrent.Semaphore;
import java.util.stream.Collectors;
import electrosphere.engine.Globals;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
public class ActorMeshMask {
@ -45,7 +45,7 @@ public class ActorMeshMask {
for(MeshDrawQueueItem item : queuedMeshes){
if((model = Globals.assetManager.fetchModel(item.getModelName())) != null){
if((mesh = model.getMesh(item.getMeshName())) != null){
toDrawMesh.put(mesh.nodeID,mesh);
toDrawMesh.put(mesh.getMeshName(),mesh);
toRemove.add(item);
}
}

4
src/main/java/electrosphere/renderer/actor/instance/InstanceManager.java
View File

@ -7,11 +7,11 @@ import java.util.Map;
import electrosphere.engine.Globals;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderPipelineState;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.buffer.ShaderAttribute;
import electrosphere.renderer.buffer.HomogenousUniformBuffer.HomogenousBufferTypes;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
/**
* Manages all instanced actors. This is what actually does the draw call in opengl.

2
src/main/java/electrosphere/renderer/actor/instance/InstancedActor.java
View File

@ -15,9 +15,9 @@ import electrosphere.entity.Entity;
import electrosphere.entity.EntityDataStrings;
import electrosphere.entity.EntityUtils;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderPipelineState;
import electrosphere.renderer.buffer.ShaderAttribute;
import electrosphere.renderer.model.Model;
/**
* An instanced actor is a static (not bone animated) actor for an instanced model (eg grass, trees, leaves, rocks, etc)

4
src/main/java/electrosphere/renderer/debug/DebugRendering.java
View File

@ -11,9 +11,9 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.ui.ContainerElement;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.Element;

16
src/main/java/electrosphere/renderer/loading/ModelLoader.java
View File

@ -3,9 +3,9 @@ package electrosphere.renderer.loading;
import electrosphere.engine.Globals;
import electrosphere.engine.Main;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.texture.Texture;
import electrosphere.renderer.texture.TextureMap;
import electrosphere.util.FileUtils;
@ -68,15 +68,15 @@ public class ModelLoader {
Iterator<Mesh> mesh_iterator = m.meshes.iterator();
while(mesh_iterator.hasNext()){
Mesh current_mesh = mesh_iterator.next();
LoggerInterface.loggerRenderer.DEBUG(current_mesh.nodeID);
LoggerInterface.loggerRenderer.DEBUG(current_mesh.getMeshName());
//if the current iteration is contained within the mesh map we procured from above
if(mesh_map.containsKey(current_mesh.nodeID)){
if(mesh_map.containsKey(current_mesh.getMeshName())){
//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();
List<String> texture_path_list = mesh_map.get(current_mesh.nodeID);
List<String> texture_path_list = mesh_map.get(current_mesh.getMeshName());
String diffuse_path = TextureMap.get_diffuse_path(texture_path_list);
LoggerInterface.loggerRenderer.DEBUG(current_mesh.nodeID + "->" + diffuse_path);
LoggerInterface.loggerRenderer.DEBUG(current_mesh.getMeshName() + "->" + diffuse_path);
if(diffuse_path != null){
LoggerInterface.loggerRenderer.DEBUG(diffuse_path);
// Texture diffuse = new Texture(diffuse_path);
@ -99,7 +99,7 @@ public class ModelLoader {
//set the current mesh's material to this new one
current_mesh.setMaterial(final_material);
} else {
LoggerInterface.loggerRenderer.WARNING("Failed to load texture for node " + current_mesh.nodeID + " of model " + path);
LoggerInterface.loggerRenderer.WARNING("Failed to load texture for node " + current_mesh.getMeshName() + " of model " + path);
}
}
}

47
src/main/java/electrosphere/renderer/meshgen/FluidChunkModelGeneration.java
View File

@ -13,10 +13,10 @@ import org.lwjgl.BufferUtils;
import electrosphere.engine.Globals;
import electrosphere.entity.types.fluid.FluidChunkModelData;
import electrosphere.renderer.Material;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;
@ -677,16 +677,14 @@ public class FluidChunkModelGeneration {
*/
protected static Mesh generateFluidMesh(FluidChunkModelData data){
Mesh mesh = new Mesh();
Mesh mesh = new Mesh("fluidChunk");
mesh.mesh = null;
//
// VAO
//
mesh.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(mesh.vertexArrayObject);
mesh.generateVAO();
@ -698,14 +696,14 @@ public class FluidChunkModelGeneration {
//
try {
mesh.vertexCount = data.getVertices().size() / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(mesh.vertexCount * 3);
int vertexCount = data.getVertices().size() / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(vertexCount * 3);
float[] temp = new float[3];
for(float vertValue : data.getVertices()){
VertexArrayBufferData.put(vertValue);
}
VertexArrayBufferData.flip();
mesh.buffer_vertices(VertexArrayBufferData, 3);
mesh.bufferVertices(VertexArrayBufferData, 3);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -715,16 +713,16 @@ public class FluidChunkModelGeneration {
//
// FACES
//
mesh.faceCount = data.getFaceElements().size() / 3;
mesh.elementCount = data.getFaceElements().size();
int faceCount = data.getFaceElements().size() / 3;
int elementCount = data.getFaceElements().size();
try {
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(mesh.elementCount);
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(elementCount);
int[] temp = new int[3];
for(int element : data.getFaceElements()){
elementArrayBufferData.put(element);
}
elementArrayBufferData.flip();
mesh.buffer_faces(elementArrayBufferData);
mesh.bufferFaces(elementArrayBufferData,elementCount);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -736,16 +734,16 @@ public class FluidChunkModelGeneration {
// NORMALS
//
try {
mesh.normalCount = data.getNormals().size() / 3;
int normalCount = data.getNormals().size() / 3;
FloatBuffer NormalArrayBufferData;
if(mesh.normalCount > 0){
NormalArrayBufferData = BufferUtils.createFloatBuffer(mesh.normalCount * 3);
if(normalCount > 0){
NormalArrayBufferData = BufferUtils.createFloatBuffer(normalCount * 3);
float[] temp = new float[3];
for(float normalValue : data.getNormals()){
NormalArrayBufferData.put(normalValue);
}
NormalArrayBufferData.flip();
mesh.buffer_normals(NormalArrayBufferData, 3);
mesh.bufferNormals(NormalArrayBufferData, 3);
}
} catch (NullPointerException ex){
ex.printStackTrace();
@ -755,16 +753,16 @@ public class FluidChunkModelGeneration {
// TEXTURE COORDINATES
//
try {
mesh.textureCoordCount = data.getUVs().size() / 2;
int textureCoordCount = data.getUVs().size() / 2;
FloatBuffer TextureArrayBufferData;
if(mesh.textureCoordCount > 0){
TextureArrayBufferData = BufferUtils.createFloatBuffer(mesh.textureCoordCount * 2);
if(textureCoordCount > 0){
TextureArrayBufferData = BufferUtils.createFloatBuffer(textureCoordCount * 2);
float[] temp = new float[2];
for(float uvValue : data.getUVs()){
TextureArrayBufferData.put(uvValue);
}
TextureArrayBufferData.flip();
mesh.buffer_texture_coords(TextureArrayBufferData, 2);
mesh.bufferTextureCoords(TextureArrayBufferData, 2);
}
} catch (NullPointerException ex){
ex.printStackTrace();
@ -774,7 +772,6 @@ public class FluidChunkModelGeneration {
glBindVertexArray(0);
mesh.nodeID = "fluidChunk";
return mesh;
}
@ -797,7 +794,7 @@ public class FluidChunkModelGeneration {
m.setMaterial(groundMat);
m.setShader(FluidChunkModelGeneration.fluidChunkShaderProgram);
m.parent = rVal;
m.setParent(rVal);
rVal.meshes.add(m);

330
src/main/java/electrosphere/renderer/meshgen/MeshLoader.java Normal file
View File

@ -0,0 +1,330 @@
package electrosphere.renderer.meshgen;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.HashMap;
import java.util.Iterator;
import org.joml.Matrix4d;
import org.joml.Vector4d;
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.AIVector3D;
import org.lwjgl.assimp.AIVertexWeight;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.loading.ModelPretransforms;
import electrosphere.renderer.model.Bone;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.shader.ShaderProgram;
/**
* Main class for loading meshes from assimp scenes
*/
public class MeshLoader {
public static Mesh createMeshFromAIScene(AIMesh mesh, ModelPretransforms.MeshMetadata metadata){
boolean has_bones = false;
boolean apply_lighting = true;
Mesh rVal = new Mesh(mesh.mName().dataString());
//
// VAO
//
//Check for headless to not call gl functions when not running with gpu
if(!Globals.HEADLESS){
rVal.generateVAO();
}
//Basic checks
//check num vertices
int numVertices = mesh.mNumVertices();
AIVector3D.Buffer vertexData = mesh.mVertices();
// while(vertexData.hasRemaining()){
// vertexData.get();
// numVertices++;
// }
// vertexData = vertexData.rewind();
//check num normals
int numNormals = mesh.mNumVertices();
// AIVector3D.Buffer normalData = mesh.mNormals();
// while(normalData.hasRemaining()){
// normalData.get();
// numNormals++;
// }
// normalData.rewind();
if(numVertices != numNormals){
LoggerInterface.loggerNetworking.ERROR("Catastrophic failure: Number of vertices =/= Number of normals", new Exception("Catastrophic failure: Number of vertices =/= Number of normals"));
}
Matrix4d vertexPretransform = new Matrix4d().identity();
if(metadata != null){
LoggerInterface.loggerRenderer.DEBUG("Pretransforming");
vertexPretransform.translationRotateScale(metadata.getOffset(), metadata.getRotation(), metadata.getScale());
}
//
//Buffer data to GPU
//
vertexData.rewind();
int vertexCount = 0;
try {
vertexCount = mesh.mNumVertices();
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(vertexCount * 3);
float[] temp = new float[3];
boolean definedDimensions = false;
float minX = 0, maxX = 0, minY = 0, maxY = 0, minZ = 0, maxZ = 0;
for (int i = 0; i < vertexCount; i++) {
AIVector3D vertex = vertexData.get();
float x = vertex.x();
float y = vertex.y();
float z = vertex.z();
//store dimensions of the model
if(definedDimensions){
if(x < minX){ minX = x; }
if(x > maxX){ maxX = x; }
if(y < minY){ minY = y; }
if(y > maxY){ maxY = y; }
if(z < minZ){ minZ = z; }
if(z > maxZ){ maxZ = z; }
} else {
definedDimensions = true;
minX = maxX = x;
minY = maxY = y;
minZ = maxZ = z;
}
//update bounding sphere
double dist = Math.sqrt(x*x+y*y+z*z);
if(dist > rVal.getBoundingSphere().r){
rVal.getBoundingSphere().r = dist;
}
//store vertex data
Vector4d transformedVertex = vertexPretransform.transform(new Vector4d(x,y,z,1.0));
transformedVertex.w = 1.0;
temp[0] = (float)transformedVertex.x;
temp[1] = (float)transformedVertex.y;
temp[2] = (float)transformedVertex.z;
VertexArrayBufferData.put(temp);
}
VertexArrayBufferData.flip();
rVal.bufferVertices(VertexArrayBufferData, 3);
} catch (NullPointerException ex){
ex.printStackTrace();
}
//
// NORMALS
//
AIVector3D.Buffer normals = mesh.mNormals();
try {
int normalCount = mesh.mNumVertices();
FloatBuffer NormalArrayBufferData;
if(normalCount > 0){
NormalArrayBufferData = BufferUtils.createFloatBuffer(normalCount * 3);
float[] temp = new float[3];
for (int i = 0; i < 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.bufferNormals(NormalArrayBufferData, 3);
}
} catch (NullPointerException ex){
ex.printStackTrace();
}
//
// FACES
//
int faceCount = mesh.mNumFaces();
int elementCount = faceCount * 3;
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(elementCount);
AIFace.Buffer facesBuffer = mesh.mFaces();
for(int i = 0; i < faceCount; i++){
AIFace face = facesBuffer.get(i);
if(face.mNumIndices() != 3){
throw new IllegalStateException("AIFace.mNumIndices() != 3");
}
elementArrayBufferData.put(face.mIndices());
}
elementArrayBufferData.flip();
rVal.bufferFaces(elementArrayBufferData,elementCount);
//
// TEXTURE COORDINATES
//
if(mesh.mTextureCoords().capacity() > 0){
AIVector3D.Buffer texturecoords = mesh.mTextureCoords(0);
try {
int textureCoordCount = mesh.mTextureCoords(0).capacity();
FloatBuffer TextureArrayBufferData;
if(textureCoordCount > 0){
TextureArrayBufferData = BufferUtils.createFloatBuffer(textureCoordCount * 2);
float[] temp = new float[2];
for (int i = 0; i < 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.bufferTextureCoords(TextureArrayBufferData, 2);
}
} 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(currentBoneData);
currentBone.boneID = currentBoneData.mName().dataString();
currentBone.inverseBindPoseMatrix = electrosphere.util.Utilities.convertAIMatrixd(currentBoneData.mOffsetMatrix());
Iterator<AIVertexWeight> weightIterator = currentBoneData.mWeights().iterator();
while(weightIterator.hasNext()){
AIVertexWeight currentWeightData = weightIterator.next();
currentBone.putWeight(currentWeightData.mVertexId(), currentWeightData.mWeight());
}
rVal.getBones().add(currentBone);
rVal.registerBoneId(currentBone.boneID);
}
FloatBuffer boneWeightDataBuffer = BufferUtils.createFloatBuffer(4 * vertexCount);//FloatBuffer.allocate(4 * vertexCount);
FloatBuffer boneIndexDataBuffer = BufferUtils.createFloatBuffer(4 * vertexCount);//IntBuffer.allocate(4 * vertexCount);
Iterator<Bone> boneIterator;
for(int i = 0; i < vertexCount; i++){
float[] weight = new float[4];
float[] index = new float[4];
int boneCounter = 0;
boneIterator = rVal.getBones().iterator();
while(boneIterator.hasNext()){
Bone currentBone = boneIterator.next();
float boneVal = 0;
if(currentBone.getWeights().get(i) != null){
boneVal = currentBone.getWeights().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;
// if(rVal.nodeID.equals("Torso")){
// System.out.println(index[3] + " " + index[2] + " " + index[1] + " " + index[0]);
// }
} 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);
}
//If all are 0 (for instance the vertex doesn't have any bones with any weight > 0), the values for each weight will be NaN after the divide immediately above
//If NaN, set all to 0
if(Float.isNaN(weight[0])){
weight[0] = 0;
weight[1] = 0;
weight[2] = 0;
weight[3] = 0;
}
boneIndexDataBuffer.put(index);
boneWeightDataBuffer.put(weight);
}
boneIndexDataBuffer.flip();
boneWeightDataBuffer.flip();
if(!Globals.HEADLESS){
rVal.bufferBoneIndices(boneIndexDataBuffer);
rVal.bufferBoneWeights(boneWeightDataBuffer);
}
}
if(!Globals.HEADLESS){
rVal.setShader(ShaderProgram.smart_assemble_shader(has_bones, apply_lighting));
rVal.setShader(ShaderProgram.smart_assemble_shader(has_bones, apply_lighting));
rVal.setOITShader(ShaderProgram.smartAssembleOITProgram(has_bones, apply_lighting));
}
return rVal;
}
}

245
src/main/java/electrosphere/renderer/meshgen/SkyboxMeshgen.java Normal file
View File

@ -0,0 +1,245 @@
package electrosphere.renderer.meshgen;
/**
* Utilities for generating and managing skyboxes
*/
public class SkyboxMeshgen {
// public static Model createSkyboxModel(Material optionalMaterial){
// Model skyboxModel = new Model();
// skyboxModel.meshes = new ArrayList<Mesh>();
// skyboxModel.modelMatrix = new Matrix4d();
// // boolean apply_lighting = false;
// // boolean has_bones = false;
// Mesh skyboxmesh = new Mesh("skybox"){
// @Override
// public void complexDraw(RenderPipelineState renderPipelineState){
// if(renderPipelineState.getUseMeshShader()){
// GL11.glDepthFunc(GL_LEQUAL);
// glUseProgram(shader.getShaderId());
// }
// if(renderPipelineState.getUseMaterial()){
// if(this.getMaterial() == null){
// Globals.materialDefault.apply_material(0,1);
// Iterator<Vector3f> colorIterator = Globals.skyboxColors.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.getShaderId(), "colors[" + counter + "]"), temp);
// counter++;
// }
// }
// }
// glBindVertexArray(vertexArrayObject);
// if(renderPipelineState.getBufferStandardUniforms()){
// //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, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
// }
// GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
// glBindVertexArray(0);
// if(renderPipelineState.getUseMeshShader()){
// GL11.glDepthFunc(GL_LESS);
// }
// }
// };
// //
// // VAO
// //
// skyboxmesh.generateVAO();
// float[] vertexcoords = {
// 100.0f, 100.0f, 100.0f,
// 100.0f, 100.0f,-100.0f,
// 100.0f,-100.0f, 100.0f,
// 100.0f,-100.0f,-100.0f,
// -100.0f, 100.0f, 100.0f,
// -100.0f, 100.0f,-100.0f,
// -100.0f,-100.0f, 100.0f,
// -100.0f,-100.0f,-100.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, 3);
// } 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, 3);
// }
// } 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.setHasBones(false);
// glBindVertexArray(0);
// skyboxmesh.setParent(skyboxModel);
// skyboxModel.meshes.add(skyboxmesh);
// return skyboxModel;
// }
}

48
src/main/java/electrosphere/renderer/meshgen/TerrainChunkModelGeneration.java
View File

@ -21,10 +21,10 @@ import static org.lwjgl.opengl.GL30.glGenVertexArrays;
import electrosphere.engine.Globals;
import electrosphere.entity.types.terrain.TerrainChunkData;
import electrosphere.renderer.Material;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.server.terrain.manager.ServerTerrainChunk;
public class TerrainChunkModelGeneration {
@ -683,16 +683,13 @@ public class TerrainChunkModelGeneration {
*/
protected static Mesh generateTerrainMesh(TerrainChunkData data){
Mesh mesh = new Mesh();
Mesh mesh = new Mesh("terrainChunk");
mesh.mesh = null;
//
// VAO
//
mesh.vertexArrayObject = glGenVertexArrays();
glBindVertexArray(mesh.vertexArrayObject);
mesh.generateVAO();
@ -704,14 +701,14 @@ public class TerrainChunkModelGeneration {
//
try {
mesh.vertexCount = data.getVertices().size() / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(mesh.vertexCount * 3);
int vertexCount = data.getVertices().size() / 3;
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(vertexCount * 3);
float[] temp = new float[3];
for(float vertValue : data.getVertices()){
VertexArrayBufferData.put(vertValue);
}
VertexArrayBufferData.flip();
mesh.buffer_vertices(VertexArrayBufferData, 3);
mesh.bufferVertices(VertexArrayBufferData, 3);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -721,16 +718,16 @@ public class TerrainChunkModelGeneration {
//
// FACES
//
mesh.faceCount = data.getFaceElements().size() / 3;
mesh.elementCount = data.getFaceElements().size();
int faceCount = data.getFaceElements().size() / 3;
int elementCount = data.getFaceElements().size();
try {
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(mesh.elementCount);
IntBuffer elementArrayBufferData = BufferUtils.createIntBuffer(elementCount);
int[] temp = new int[3];
for(int element : data.getFaceElements()){
elementArrayBufferData.put(element);
}
elementArrayBufferData.flip();
mesh.buffer_faces(elementArrayBufferData);
mesh.bufferFaces(elementArrayBufferData,elementCount);
} catch (NullPointerException ex){
ex.printStackTrace();
}
@ -742,16 +739,16 @@ public class TerrainChunkModelGeneration {
// NORMALS
//
try {
mesh.normalCount = data.getNormals().size() / 3;
int normalCount = data.getNormals().size() / 3;
FloatBuffer NormalArrayBufferData;
if(mesh.normalCount > 0){
NormalArrayBufferData = BufferUtils.createFloatBuffer(mesh.normalCount * 3);
if(normalCount > 0){
NormalArrayBufferData = BufferUtils.createFloatBuffer(normalCount * 3);
float[] temp = new float[3];
for(float normalValue : data.getNormals()){
NormalArrayBufferData.put(normalValue);
}
NormalArrayBufferData.flip();
mesh.buffer_normals(NormalArrayBufferData, 3);
mesh.bufferNormals(NormalArrayBufferData, 3);
}
} catch (NullPointerException ex){
ex.printStackTrace();
@ -761,16 +758,16 @@ public class TerrainChunkModelGeneration {
// TEXTURE COORDINATES
//
try {
mesh.textureCoordCount = data.getUVs().size() / 2;
int textureCoordCount = data.getUVs().size() / 2;
FloatBuffer TextureArrayBufferData;
if(mesh.textureCoordCount > 0){
TextureArrayBufferData = BufferUtils.createFloatBuffer(mesh.textureCoordCount * 2);
if(textureCoordCount > 0){
TextureArrayBufferData = BufferUtils.createFloatBuffer(textureCoordCount * 2);
float[] temp = new float[2];
for(float uvValue : data.getUVs()){
TextureArrayBufferData.put(uvValue);
}
TextureArrayBufferData.flip();
mesh.buffer_texture_coords(TextureArrayBufferData, 2);
mesh.bufferTextureCoords(TextureArrayBufferData, 2);
}
} catch (NullPointerException ex){
ex.printStackTrace();
@ -787,7 +784,6 @@ public class TerrainChunkModelGeneration {
glBindVertexArray(0);
mesh.nodeID = "terrainChunk";
return mesh;
}
@ -810,7 +806,7 @@ public class TerrainChunkModelGeneration {
m.setMaterial(groundMat);
m.setShader(TerrainChunkModelGeneration.terrainChunkShaderProgram);
m.parent = rVal;
m.setParent(rVal);
rVal.meshes.add(m);
rVal.setBoundingSphere(m.getBoundingSphere());

6
src/main/java/electrosphere/renderer/meshgen/TransvoxelModelGeneration.java
View File

@ -13,11 +13,11 @@ import org.lwjgl.BufferUtils;
import electrosphere.engine.Globals;
import electrosphere.entity.types.terrain.TerrainChunkData;
import electrosphere.renderer.Material;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.meshgen.TerrainChunkModelGeneration.GridCell;
import electrosphere.renderer.meshgen.TerrainChunkModelGeneration.Triangle;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
/**
* Utility functions for generating transvoxel based meshes

28
src/main/java/electrosphere/renderer/Bone.java → src/main/java/electrosphere/renderer/model/Bone.java
View File

@ -1,22 +1,19 @@
package electrosphere.renderer;
package electrosphere.renderer.model;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.joml.Matrix4d;
import org.joml.Matrix4f;
import org.lwjgl.assimp.AIBone;
import electrosphere.renderer.loading.ModelPretransforms;
/**
*
* @author satellite
* Keeps track of bone data
*/
public class Bone {
public String boneID;
int numWeights;
HashMap<Integer,Float> weights;
Map<Integer,Float> weights = new HashMap<Integer,Float>();
public Matrix4d inverseBindPoseMatrix;
public Matrix4d deform;
public Matrix4d transform;
@ -33,6 +30,23 @@ public class Bone {
final_transform = new Matrix4d();
boneID = raw_data.mName().dataString();
inverseBindPoseMatrix = electrosphere.util.Utilities.convertAIMatrixd(raw_data.mOffsetMatrix());
numWeights = raw_data.mNumWeights();
this.raw_data = raw_data;
}
/**
* Stores a bone weight
* @param index the index of the bone in the bone array in shader
* @param weight the weight for the given bone
*/
public void putWeight(int index, float weight){
weights.put(index,weight);
}
/**
* Returns the weight map
*/
public Map<Integer,Float> getWeights(){
return weights;
}
}

6
src/main/java/electrosphere/renderer/Material.java → src/main/java/electrosphere/renderer/model/Material.java
View File

@ -1,4 +1,4 @@
package electrosphere.renderer;
package electrosphere.renderer.model;
import electrosphere.engine.Globals;
import electrosphere.renderer.texture.Texture;
@ -74,12 +74,12 @@ public class Material {
Texture diffuseTexture = Globals.assetManager.fetchTexture(diffuse);
if(diffuseTexture != null){
diffuseTexture.bind(0);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "material.diffuse"), 0);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "material.diffuse"), 0);
}
Texture specularTexture = Globals.assetManager.fetchTexture(specular);
if(specularTexture != null){
specularTexture.bind(1);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "material.specular"), 1);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "material.specular"), 1);
}
} else {
glActiveTexture(GL_TEXTURE0);

541
src/main/java/electrosphere/renderer/model/Mesh.java Normal file
View File

@ -0,0 +1,541 @@
package electrosphere.renderer.model;
import electrosphere.engine.Globals;
import electrosphere.entity.types.camera.CameraEntityUtils;
import electrosphere.renderer.RenderPipelineState;
import electrosphere.renderer.RenderPipelineState.SelectedShaderEnum;
import electrosphere.renderer.actor.ActorTextureMask;
import electrosphere.renderer.actor.instance.InstanceData;
import electrosphere.renderer.buffer.HomogenousInstancedArray;
import electrosphere.renderer.buffer.ShaderAttribute;
import electrosphere.renderer.light.LightManager;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.joml.Matrix4d;
import org.joml.Matrix4f;
import org.joml.Sphered;
import org.joml.Vector3f;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import static org.lwjgl.opengl.GL40.*;
import org.lwjgl.opengl.GL45;
/**
* A mesh, a collection of buffer data on the GPU
*/
public class Mesh {
//the name of the mesh
private String meshName;
//THIS IS NOT GUARANTEED TO BE THE PARENT MODEL THAT THIS WAS LOADED IN
//THIS CAN BE POST-LOAD SET IN MODEL VIA MODELMASK BEHAVIOR
private Model parent;
//various buffers that may or may not be allocated
private int vertexBuffer;
private int normalBuffer;
private int elementArrayBuffer;
private int elementCount;
private int vertexArrayObject;
private int boneWeightBuffer;
private int boneIndexBuffer;
private int textureCoordBuffer;
//THIS IS NOT GUARANTEED TO BE THE PARENT MODEL THAT THIS WAS LOADED IN
//THIS CAN BE POST-LOAD SET IN MODEL VIA MODELMASK BEHAVIOR
private List<Bone> bones = new ArrayList<Bone>();
private ArrayList<String> boneIdList = new ArrayList<String>();
//the texture mask that may or may not be masking the mesh
private ActorTextureMask textureMask;
//the shaders currently associated with the mesh
private ShaderProgram shader;
private ShaderProgram oitShader;
//the uniforms to be sent to the gpu
private HashMap<String,Object> uniforms = new HashMap<String,Object>();
//the material currently associated with the mesh
private Material material;
//the bounding sphere for this mesh
private Sphered boundingSphere;
/**
* Creates a mesh (does not initialize any data)
* @param name The name of the mesh
*/
public Mesh(String name){
this.meshName = name;
this.boundingSphere = new Sphered();
}
/**
* Generates the VAO for this mesh
*/
public void generateVAO(){
vertexArrayObject = glGenVertexArrays();
glBindVertexArray(vertexArrayObject);
}
/**
* Buffers vertex data to the gpu under this mesh container
* @param verticies the vertex buffer
* @param vertexDimension the dimensionality of the data (2d vectors, 3d vectors, 4d vectors, etc)
*/
public void bufferVertices(FloatBuffer verticies, int vertexDimension){
if(!Globals.HEADLESS){
vertexBuffer = bufferCustomFloatAttribArray(verticies,vertexDimension,0);
}
}
/**
* Buffers normals to the gpu under this mesh container
* @param normals the normal data
* @param normalDimension the dimensionality of the data (2d vector, 3d vector, 4d vector)
*/
public void bufferNormals(FloatBuffer normals, int normalDimension){
if(!Globals.HEADLESS){
normalBuffer = bufferCustomFloatAttribArray(normals,normalDimension,1);
}
}
/**
* Buffers faces to the GPU
* @param faces The face data
* @param elementCount The number of faces
*/
public void bufferFaces(IntBuffer faces, int elementCount){
if(!Globals.HEADLESS){
elementArrayBuffer = glGenBuffers();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBuffer);
GL15.glBufferData(GL_ELEMENT_ARRAY_BUFFER, faces, GL_STATIC_DRAW);
this.elementCount = elementCount;
}
}
/**
* Buffers texture coordinates to the gpu
* @param coords the texture coordinates data
* @param textureDimension The dimensionality of the texture coordinate data (3d vec, 4d vec, etc)
*/
public void bufferTextureCoords(FloatBuffer coords, int textureDimension){
if(!Globals.HEADLESS){
textureCoordBuffer = bufferCustomFloatAttribArray(coords, textureDimension, 4);
}
}
/**
* Buffers bone indices to the GPU
* @param buffer The buffer containing the bone indices
*/
public void bufferBoneIndices(FloatBuffer buffer){
boneIndexBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, boneIndexBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(3, 4, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(3);
}
/**
* Buffers bone weights to the gpu
* @param buffer The buffer containing the bone weights
*/
public void bufferBoneWeights(FloatBuffer buffer){
boneWeightBuffer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, boneWeightBuffer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(2, 4, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(2);
}
/**
* Sends a float buffer to the gpu
* @param buffer The buffer
* @param bufferDimension The dimensionality of the buffer (2d vector, 3d vector, 4d vector)
* @param attribIndex The attribute index of the buffer (ie what number will it show up as in the shader)
* @return The pointer to the opengl buffer created
*/
public int bufferCustomFloatAttribArray(FloatBuffer buffer, int bufferDimension, int attribIndex){
int bufferPointer = 0;
if(!Globals.HEADLESS){
bufferPointer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, bufferPointer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_FLOAT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
return bufferPointer;
}
/**
* Sends an int buffer to the gpu
* @param buffer The buffer
* @param bufferDimension The dimensionality of the buffer (2d vector, 3d vector, 4d vector)
* @param attribIndex The attribute index of the buffer (ie what number will it show up as in the shader)
* @return The pointer to the opengl buffer created
*/
public int bufferCustomIntAttribArray(IntBuffer buffer, int bufferDimension, int attribIndex){
int bufferPointer = 0;
if(!Globals.HEADLESS){
bufferPointer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, bufferPointer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_INT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
return bufferPointer;
}
/**
* Sends an unsigned int buffer to the gpu
* @param buffer The buffer
* @param bufferDimension The dimensionality of the buffer (2d vector, 3d vector, 4d vector)
* @param attribIndex The attribute index of the buffer (ie what number will it show up as in the shader)
* @return The pointer to the opengl buffer created
*/
public int bufferCustomUIntAttribArray(IntBuffer buffer, int bufferDimension, int attribIndex){
int bufferPointer = 0;
if(!Globals.HEADLESS){
bufferPointer = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, bufferPointer);
GL15.glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glVertexAttribPointer(attribIndex, bufferDimension, GL_UNSIGNED_INT, false, 0, 0);
glEnableVertexAttribArray(attribIndex);
}
return bufferPointer;
}
/**
* Sets the texture mask for the mesh
* @param textureMask the texture mask
*/
public void setTextureMask(ActorTextureMask textureMask){
this.textureMask = textureMask;
}
/**
* Sets the material for the mesh
* @param material the material
*/
public void setMaterial(Material material){
this.material = material;
}
/**
* Sets the shader of this mesh
* @param shader The shader
*/
public void setShader(ShaderProgram shader){
this.shader = shader;
}
/**
* Gets the shader of this mesh
* @return The shader
*/
public ShaderProgram getShader(){
return shader;
}
/**
* Sets the order independent transparency shader
* @param shader The shader
*/
public void setOITShader(ShaderProgram shader){
this.oitShader = shader;
}
/**
* Sets a uniform on the mesh
* @param key the uniform key
* @param o the value to set the uniform to
*/
public void setUniform(String key, Object o){
uniforms.put(key, o);
}
void bufferAllUniforms(){
for(String key : uniforms.keySet()){
Object currentUniformRaw = uniforms.get(key);
if(currentUniformRaw instanceof Matrix4f){
Matrix4f currentUniform = (Matrix4f)currentUniformRaw;
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), key), false, currentUniform.get(new float[16]));
}
if(currentUniformRaw instanceof Vector3f){
Vector3f currentUniform = (Vector3f)currentUniformRaw;
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), key), currentUniform.get(BufferUtils.createFloatBuffer(3)));
}
if(currentUniformRaw instanceof Integer){
int currentInform = (Integer)currentUniformRaw;
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), key), currentInform);
}
}
}
/**
* Sends a buffer to the gpu
* @param uniformTypeMap The type of the buffer
* @param buffers The buffer
*/
void bufferInstanceData(
RenderPipelineState renderPipelineState,
Map<ShaderAttribute,Object> buffers,
Map<ShaderAttribute,HomogenousInstancedArray> uniformGlBufferMap
){
for(ShaderAttribute attribute : buffers.keySet()){
HomogenousInstancedArray buffer = uniformGlBufferMap.get(attribute);
buffer.updateBuffer(buffers.get(attribute), 0);
buffer.bind(renderPipelineState);
}
}
/**
* Draws the mesh
* @param renderPipelineState The state of the render pipeline
*/
public void complexDraw(RenderPipelineState renderPipelineState){
if(renderPipelineState.getUseMeshShader()){
ShaderProgram selectedProgram = null;
switch(renderPipelineState.getSelectedShader()){
case PRIMARY: {
selectedProgram = shader;
} break;
case OIT: {
selectedProgram = oitShader;
} break;
}
if(selectedProgram == null){
selectedProgram = shader;
}
Globals.renderingEngine.setActiveShader(renderPipelineState, selectedProgram);
}
if(renderPipelineState.getUseLight()){
//Until we switch to uniform buffer objects we will have to buffer lighting data here manually each time we draw
//side note: :(
if(Globals.renderingEngine.getLightManager() == null){
//don't buffer as the light manager hasn't initialized
} else {
LightManager lightManager = Globals.renderingEngine.getLightManager();
lightManager.bindBuffer(Globals.renderingEngine.getActiveShader().getShaderId());
}
}
if(renderPipelineState.getUseMaterial() && textureMask == null){
if(material == null){
Globals.materialDefault.apply_material(0,1);
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasTransparency"), 0);
} else {
material.apply_material();
if(material.hasTransparency){
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasTransparency"), 1);
} else {
GL20.glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasTransparency"), 0);
}
}
}
glBindVertexArray(vertexArrayObject);
if(textureMask != null){
int i = 0;
// glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "groundTextures"), 5);
// for(int j = 1; j < 15; j++){
// textureList.get(0).bind(j);
// }
for(Texture texture : textureMask.getTextures()){
// System.out.println(texture.getPath() + " => groundTextures[" + i + "]" + "=>" + (i));
if(texture != null){
texture.bind(5+i);
}
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), textureMask.getUniformNames().get(i)),5+i);
i++;
}
// for(int j = i; j < 10; j++){
// glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "groundTextures[" + j + "]"),6+j);
// }
// glActiveTexture(GL_TEXTURE0);
}
if(renderPipelineState.getUseShadowMap()){
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, Globals.shadowMapTextureLoc);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "shadowMap"), 3);
}
if(renderPipelineState.getUseBones()){
//
//Handle bones
//
if(bones != null && !bones.isEmpty()){
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasBones"), 1);
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "numBones"), bones.size());
Iterator<String> boneIterator = boneIdList.iterator();
float bufferarray[] = new float[16];
int incrementer = 0;
while (boneIterator.hasNext()){
String boneName = boneIterator.next();
Bone currentBone = parent.boneMap.get(boneName);
String currentUniform = "bones[" + incrementer + "]";
if(currentBone != null){
Matrix4d currentMat = new Matrix4d(currentBone.final_transform);
currentMat.get(bufferarray);
// if(boneName.equals("Torso")){
// System.out.println("Found torso bone");
// System.out.println(currentUniform);
// System.out.println(currentMat);
// }
GL45.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), currentUniform), false, bufferarray);
} else {
// System.out.println("Bonename: " + boneName);
// System.exit(1);
GL45.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), currentUniform), false, new float[16]);
}
incrementer++;
}
} else {
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasBones"), 0);
}
} else {
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "hasBones"), 0);
}
if(renderPipelineState.getBufferStandardUniforms()){
//buffer model/view/proj matrices
GL45.glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16]));
glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexViewLoc, false, Globals.viewMatrix.get(new float[16]));
glUniformMatrix4fv(Globals.renderingEngine.getActiveShader().shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16]));
glUniform3fv(Globals.renderingEngine.getActiveShader().shaderVertexViewPosLoc, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "frame"), (int)Globals.timekeeper.getNumberOfRenderFramesElapsed());
glUniform1f(glGetUniformLocation(Globals.renderingEngine.getActiveShader().getShaderId(), "time"), (float)Globals.timekeeper.getCurrentRendererTime());
}
if(renderPipelineState.getBufferNonStandardUniforms()){
bufferAllUniforms();
}
if(renderPipelineState.getInstanced()){
InstanceData instanceData = renderPipelineState.getInstanceData();
Map<ShaderAttribute,Object> buffers = instanceData.getCpuBufferMap();
Map<ShaderAttribute,HomogenousInstancedArray> glBufferMap = instanceData.getGlBufferMap();
bufferInstanceData(renderPipelineState, buffers, glBufferMap);
}
if(renderPipelineState.getInstanced()){
GL45.glDrawElementsInstanced(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0, renderPipelineState.getInstanceData().getDrawCount());
} else {
GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
}
glBindVertexArray(0);
}
/**
* Updates the bounding sphere of the mesh
* @param x
* @param y
* @param z
* @param r
*/
public void updateBoundingSphere(float x, float y, float z, float r){
this.boundingSphere.x = x;
this.boundingSphere.y = y;
this.boundingSphere.z = z;
this.boundingSphere.r = r;
}
/**
* Gets the bounding sphere of this mesh
* @return The bounding sphere
*/
public Sphered getBoundingSphere(){
return this.boundingSphere;
}
/**
* Gets the material of the mesh
* @return The material
*/
public Material getMaterial(){
return material;
}
/**
* Gets whether this mesh has bones or not
* @return true if has bones
*/
public boolean hasBones(){
return bones.size() > 0;
}
/**
* Gets the name of this mesh
* @return The name of the mesh
*/
public String getMeshName(){
return meshName;
}
/**
* Sets the parent model of this mesh
* @param parent The parent
*/
public void setParent(Model parent){
this.parent = parent;
}
/**
* Gets the bones for this mesh
* @return The list of bones
*/
public List<Bone> getBones(){
return bones;
}
/**
* Sets the bones for this mesh
* @param bones The list of bones
*/
public void setBones(List<Bone> bones){
this.bones = bones;
}
/**
* Registers a bone id
* @param boneId the bone id
*/
public void registerBoneId(String boneId){
this.boneIdList.add(boneId);
}
}

55
src/main/java/electrosphere/renderer/Model.java → src/main/java/electrosphere/renderer/model/Model.java
View File

@ -1,5 +1,6 @@
package electrosphere.renderer;
package electrosphere.renderer.model;
import electrosphere.renderer.RenderPipelineState;
import electrosphere.renderer.actor.ActorAnimationMask;
import electrosphere.renderer.actor.ActorBoneRotator;
import electrosphere.renderer.actor.ActorMeshMask;
@ -10,6 +11,8 @@ import electrosphere.renderer.anim.AnimChannel;
import electrosphere.renderer.anim.Animation;
import electrosphere.renderer.loading.ModelPretransforms;
import electrosphere.renderer.loading.ModelPretransforms.MeshMetadata;
import electrosphere.renderer.meshgen.MeshLoader;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.anim.AnimNode;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
@ -107,12 +110,12 @@ public class Model {
if(modelMetadata != null){
meshMetadata = modelMetadata.getMesh(aiMesh.mName().dataString());
}
Mesh currentMesh = Mesh.create_mesh_from_aimesh(aiMesh, meshMetadata);
Mesh currentMesh = MeshLoader.createMeshFromAIScene(aiMesh, meshMetadata);
rVal.meshes.add(currentMesh);
currentMesh.parent = rVal;
currentMesh.setParent(rVal);
//update model bounding sphere
if(currentMesh.boundingSphere.r > rVal.boundingSphere.r){
rVal.boundingSphere.r = currentMesh.boundingSphere.r;
if(currentMesh.getBoundingSphere().r > rVal.boundingSphere.r){
rVal.boundingSphere.r = currentMesh.getBoundingSphere().r;
}
}
//
@ -141,7 +144,7 @@ public class Model {
rVal.node_map = new HashMap<String, AnimNode>();
while(meshIterator.hasNext()){
Mesh currentMesh = meshIterator.next();
Iterator<Bone> boneIterator = currentMesh.bones.iterator();
Iterator<Bone> boneIterator = currentMesh.getBones().iterator();
ArrayList<Bone> to_remove_queue = new ArrayList<Bone>();
ArrayList<Bone> to_add_queue = new ArrayList<Bone>();
while(boneIterator.hasNext()){
@ -153,11 +156,11 @@ public class Model {
}
boneIterator = to_remove_queue.iterator();
while(boneIterator.hasNext()){
currentMesh.bones.remove(boneIterator.next());
currentMesh.getBones().remove(boneIterator.next());
}
boneIterator = to_add_queue.iterator();
while(boneIterator.hasNext()){
currentMesh.bones.add(boneIterator.next());
currentMesh.getBones().add(boneIterator.next());
}
}
//
@ -241,40 +244,40 @@ public class Model {
Iterator<Mesh> mesh_Iterator = meshes.iterator();
while(mesh_Iterator.hasNext()){
Mesh currentMesh = mesh_Iterator.next();
if(meshMask == null || (meshMask != null && !meshMask.isBlockedMesh(currentMesh.nodeID))){
if(meshMask == null || (meshMask != null && !meshMask.isBlockedMesh(currentMesh.getMeshName()))){
//set shader
ShaderProgram original = currentMesh.shader;
ShaderProgram shader = getCorrectShader(shaderMask, currentMesh, currentMesh.shader);
currentMesh.shader = shader;
ShaderProgram original = currentMesh.getShader();
ShaderProgram shader = getCorrectShader(shaderMask, currentMesh, currentMesh.getShader());
currentMesh.setShader(shader);
//set texture mask
if(this.textureMap != null && textureMap.containsKey(currentMesh.nodeID)){
currentMesh.setTextureMask(textureMap.get(currentMesh.nodeID));
if(this.textureMap != null && textureMap.containsKey(currentMesh.getMeshName())){
currentMesh.setTextureMask(textureMap.get(currentMesh.getMeshName()));
}
//draw
currentMesh.complexDraw(renderPipelineState);
//reset texture mask
currentMesh.setTextureMask(null);
//reset shader
currentMesh.shader = original;
currentMesh.setShader(original);
}
}
if(meshMask != null){
for(Mesh toDraw : meshMask.getToDrawMeshes()){
toDraw.bones = bones;
toDraw.parent = this;
ShaderProgram original = toDraw.shader;
ShaderProgram shader = getCorrectShader(shaderMask, toDraw, toDraw.shader);
toDraw.shader = shader;
toDraw.setBones(bones);
toDraw.setParent(this);
ShaderProgram original = toDraw.getShader();
ShaderProgram shader = getCorrectShader(shaderMask, toDraw, toDraw.getShader());
toDraw.setShader(shader);
toDraw.complexDraw(renderPipelineState);
toDraw.shader = original;
toDraw.setShader(original);
}
}
}
ShaderProgram getCorrectShader(Map<String,ActorShaderMask> shaderMask, Mesh mesh, ShaderProgram oldShader){
ShaderProgram rVal = oldShader;
if(shaderMask.containsKey(mesh.nodeID)){
ActorShaderMask specificMask = shaderMask.get(mesh.nodeID);
if(shaderMask.containsKey(mesh.getMeshName())){
ActorShaderMask specificMask = shaderMask.get(mesh.getMeshName());
ShaderProgram overwriteShader = null;
if((overwriteShader = Globals.assetManager.fetchShader(specificMask.getVertexShaderPath(), specificMask.getGeometryShaderPath(), specificMask.getFragmentShaderPath())) != null){
// ShaderProgram oldProgram = mesh.shader;
@ -477,7 +480,7 @@ public class Model {
public void pushUniformToMesh(String meshName, String uniformKey, Object uniform){
for(Mesh m : meshes){
if(m.nodeID.equals(meshName)){
if(m.getMeshName().equals(meshName)){
m.setUniform(uniformKey, uniform);
}
}
@ -491,7 +494,7 @@ public class Model {
public Mesh getMesh(String meshName){
for(Mesh mesh : meshes){
if(mesh.nodeID.matches(meshName)){
if(mesh.getMeshName().matches(meshName)){
return mesh;
}
}
@ -509,7 +512,7 @@ public class Model {
public void describeHighLevel(){
System.out.println("Meshes: ");
for(Mesh mesh : meshes){
System.out.println(mesh.nodeID);
System.out.println(mesh.getMeshName());
}
System.out.println("Animations: ");
for(Animation anim : animations){

133
src/main/java/electrosphere/renderer/ShaderProgram.java → src/main/java/electrosphere/renderer/shader/ShaderProgram.java
View File

@ -1,4 +1,4 @@
package electrosphere.renderer;
package electrosphere.renderer.shader;
import static org.lwjgl.opengl.GL11.GL_TRUE;
import static org.lwjgl.opengl.GL20.GL_COMPILE_STATUS;
@ -44,7 +44,7 @@ public class ShaderProgram {
int vertexShader;
int geometryShader;
int fragmentShader;
int shaderProgram;
int shaderId;
//
@ -153,16 +153,16 @@ public class ShaderProgram {
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
}
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderProgram = glCreateProgram();
rVal.shaderId = glCreateProgram();
//This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderProgram, rVal.vertexShader);
glAttachShader(rVal.shaderProgram, rVal.fragmentShader);
glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderProgram);
glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS);
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId));
}
//Deletes the individual shader objects to free up memory
@ -174,15 +174,15 @@ public class ShaderProgram {
//
//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.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderId, "model");
rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderId, "view");
rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderId, "projection");
rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderId, "viewPos");
if(ContainsBones){
rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderProgram, "bones");
rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderProgram, "numBones");
rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderId, "bones");
rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderId, "numBones");
}
rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderProgram, "hasBones");
rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderId, "hasBones");
@ -281,16 +281,16 @@ public class ShaderProgram {
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
}
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderProgram = glCreateProgram();
rVal.shaderId = glCreateProgram();
//This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderProgram, rVal.vertexShader);
glAttachShader(rVal.shaderProgram, rVal.fragmentShader);
glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderProgram);
glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS);
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId));
}
//Deletes the individual shader objects to free up memory
@ -302,15 +302,15 @@ public class ShaderProgram {
//
//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.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderId, "model");
rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderId, "view");
rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderId, "projection");
rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderId, "viewPos");
if(ContainsBones){
rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderProgram, "bones");
rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderProgram, "numBones");
rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderId, "bones");
rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderId, "numBones");
}
rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderProgram, "hasBones");
rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderId, "hasBones");
@ -396,16 +396,16 @@ public class ShaderProgram {
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
}
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderProgram = glCreateProgram();
rVal.shaderId = glCreateProgram();
//This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderProgram, rVal.vertexShader);
glAttachShader(rVal.shaderProgram, rVal.fragmentShader);
glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderProgram);
glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS);
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId));
}
//Deletes the individual shader objects to free up memory
@ -417,13 +417,13 @@ public class ShaderProgram {
//
//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");
rVal.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderId, "model");
rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderId, "view");
rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderId, "projection");
rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderId, "viewPos");
rVal.shaderVertexBonesLoc = glGetUniformLocation(rVal.shaderId, "bones");
rVal.shaderVertexNumBonesLoc = glGetUniformLocation(rVal.shaderId, "numBones");
rVal.shaderVertexHasBonesLoc = glGetUniformLocation(rVal.shaderId, "hasBones");
@ -587,16 +587,16 @@ public class ShaderProgram {
}
}
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderProgram = glCreateProgram();
rVal.shaderId = glCreateProgram();
//This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderProgram, rVal.vertexShader);
glAttachShader(rVal.shaderProgram, rVal.fragmentShader);
glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderProgram);
glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS);
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
LoggerInterface.loggerRenderer.ERROR(glGetProgramInfoLog(rVal.shaderProgram), new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram)));
LoggerInterface.loggerRenderer.ERROR(glGetProgramInfoLog(rVal.shaderId), new RuntimeException(glGetProgramInfoLog(rVal.shaderId)));
LoggerInterface.loggerRenderer.WARNING("Shader sources: " + vertexPath + " " + fragmentPath);
return Globals.defaultMeshShader;
// throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
@ -611,10 +611,10 @@ public class ShaderProgram {
//
//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.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderId, "model");
rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderId, "view");
rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderId, "projection");
rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderId, "viewPos");
@ -687,17 +687,17 @@ public class ShaderProgram {
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
}
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderProgram = glCreateProgram();
rVal.shaderId = glCreateProgram();
//This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderProgram, rVal.vertexShader);
glAttachShader(rVal.shaderProgram, rVal.geometryShader);
glAttachShader(rVal.shaderProgram, rVal.fragmentShader);
glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.geometryShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderProgram);
glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderProgram, GL_LINK_STATUS);
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId));
}
//Deletes the individual shader objects to free up memory
@ -710,15 +710,24 @@ public class ShaderProgram {
//
//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.shaderVertexModelLoc = glGetUniformLocation(rVal.shaderId, "model");
rVal.shaderVertexViewLoc = glGetUniformLocation(rVal.shaderId, "view");
rVal.shaderVertexProjectionLoc = glGetUniformLocation(rVal.shaderId, "projection");
rVal.shaderVertexViewPosLoc = glGetUniformLocation(rVal.shaderId, "viewPos");
return rVal;
}
/**
* Gets the id of the shader
* @return The shader id
*/
public int getShaderId(){
return shaderId;
}
}

4
src/main/java/electrosphere/renderer/ui/Window.java
View File

@ -14,11 +14,11 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.debug.DebugRendering;
import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.events.Event;
import electrosphere.renderer.ui.events.NavigationEvent;

4
src/main/java/electrosphere/renderer/ui/elements/ActorPanel.java
View File

@ -22,13 +22,13 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.RenderingEngine;
import electrosphere.renderer.actor.Actor;
import electrosphere.renderer.debug.DebugRendering;
import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.DraggableElement;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.events.DragEvent;

4
src/main/java/electrosphere/renderer/ui/elements/ImagePanel.java
View File

@ -7,9 +7,9 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.debug.DebugRendering;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.texture.Texture;
import electrosphere.renderer.ui.DraggableElement;
import electrosphere.renderer.ui.DrawableElement;

4
src/main/java/electrosphere/renderer/ui/elements/ScrollableContainer.java
View File

@ -8,10 +8,10 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.ContainerElement;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.Element;

6
src/main/java/electrosphere/renderer/ui/elements/Slider.java
View File

@ -4,8 +4,8 @@ import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Model;
import electrosphere.renderer.debug.DebugRendering;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.ClickableElement;
import electrosphere.renderer.ui.DraggableElement;
import electrosphere.renderer.ui.DrawableElement;
@ -102,7 +102,7 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
//bounding box/margin
planeModel.pushUniformToMesh("plane", "mPosition", boxPosition);
planeModel.pushUniformToMesh("plane", "mDimension", boxDimensions);
planeModel.pushUniformToMesh(planeModel.meshes.get(0).nodeID, "color", colorBackground);
planeModel.pushUniformToMesh(planeModel.meshes.get(0).getMeshName(), "color", colorBackground);
planeModel.drawUI();
//actual slider
@ -114,7 +114,7 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
boxDimensions = new Vector3f(ndcWidth,ndcHeight,0);
planeModel.pushUniformToMesh("plane", "mPosition", boxPosition);
planeModel.pushUniformToMesh("plane", "mDimension", boxDimensions);
planeModel.pushUniformToMesh(planeModel.meshes.get(0).nodeID, "color", colorForeground);
planeModel.pushUniformToMesh(planeModel.meshes.get(0).getMeshName(), "color", colorForeground);
planeModel.drawUI();
} else {
LoggerInterface.loggerRenderer.ERROR("Window unable to find plane model!!", new Exception());

2
src/main/java/electrosphere/renderer/ui/elements/TextBox.java
View File

@ -1,8 +1,8 @@
package electrosphere.renderer.ui.elements;
import electrosphere.renderer.Model;
import electrosphere.engine.Globals;
import electrosphere.engine.assetmanager.AssetDataStrings;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.events.Event;
import electrosphere.renderer.ui.font.FontUtils;

4
src/main/java/electrosphere/renderer/ui/elements/TextInput.java
View File

@ -1,11 +1,11 @@
package electrosphere.renderer.ui.elements;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.engine.Globals;
import electrosphere.engine.assetmanager.AssetDataStrings;
import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.texture.Texture;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.Element;

2
src/main/java/electrosphere/renderer/ui/font/Font.java
View File

@ -4,7 +4,7 @@ import java.util.HashMap;
import java.util.List;
import org.joml.Vector3f;
import electrosphere.renderer.Material;
import electrosphere.renderer.model.Material;
/**
* A font

2
src/main/java/electrosphere/renderer/ui/font/FontManager.java
View File

@ -6,7 +6,7 @@ import java.util.HashMap;
import java.util.Map;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.model.Material;
import electrosphere.util.FileUtils;
/**

2
src/main/java/electrosphere/renderer/ui/font/FontUtils.java
View File

@ -1,6 +1,6 @@
package electrosphere.renderer.ui.font;
import electrosphere.renderer.Material;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.texture.Texture;
import java.awt.image.BufferedImage;

4
src/main/java/electrosphere/renderer/ui/font/bitmapchar/BitmapCharacter.java
View File

@ -2,8 +2,8 @@ package electrosphere.renderer.ui.font.bitmapchar;
import electrosphere.engine.Globals;
import electrosphere.engine.assetmanager.AssetDataStrings;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.events.Event;
import electrosphere.renderer.ui.font.Font;

4
src/main/java/electrosphere/renderer/ui/layout/LayoutSchemeListScrollable.java
View File

@ -13,11 +13,11 @@ import java.util.List;
import org.joml.Vector3f;
import electrosphere.engine.Globals;
import electrosphere.renderer.Material;
import electrosphere.renderer.Model;
import electrosphere.renderer.debug.DebugRendering;
import electrosphere.renderer.framebuffer.Framebuffer;
import electrosphere.renderer.framebuffer.FramebufferUtils;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.ui.DrawableElement;
import electrosphere.renderer.ui.Element;
import electrosphere.renderer.ui.events.Event;

2
src/main/java/electrosphere/server/datacell/physics/DataCellPhysicsManager.java
View File

@ -6,7 +6,7 @@ import electrosphere.client.terrain.manager.ClientTerrainManager;
import electrosphere.engine.Globals;
import electrosphere.game.terrain.processing.TerrainInterpolator;
import electrosphere.net.parser.net.message.TerrainMessage;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.server.datacell.Realm;
import electrosphere.server.terrain.manager.ServerTerrainManager;

7
src/main/java/electrosphere/server/datacell/physics/PhysicsDataCell.java
View File

@ -12,12 +12,11 @@ import electrosphere.entity.ServerEntityUtils;
import electrosphere.entity.types.terrain.TerrainChunk;
import electrosphere.game.terrain.processing.TerrainInterpolator;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.ModelUtils;
import electrosphere.renderer.RenderUtils;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.actor.ActorTextureMask;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import electrosphere.server.datacell.Realm;
import electrosphere.server.terrain.manager.ServerTerrainManager;

2
src/main/java/electrosphere/server/poseactor/PoseActor.java
View File

@ -15,11 +15,11 @@ import org.joml.Vector4d;
import org.joml.Vector4f;
import electrosphere.engine.Globals;
import electrosphere.renderer.Bone;
import electrosphere.renderer.actor.ActorAnimationMask;
import electrosphere.renderer.actor.ActorBoneRotator;
import electrosphere.renderer.actor.ActorStaticMorph;
import electrosphere.renderer.actor.ActorStaticMorph.StaticMorphTransforms;
import electrosphere.renderer.model.Bone;
/**
* An actor that references a posemodel

2
src/main/java/electrosphere/server/poseactor/PoseModel.java
View File

@ -18,13 +18,13 @@ import org.lwjgl.assimp.AIScene;
import electrosphere.engine.Globals;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Bone;
import electrosphere.renderer.actor.ActorBoneRotator;
import electrosphere.renderer.actor.ActorStaticMorph;
import electrosphere.renderer.anim.AnimChannel;
import electrosphere.renderer.anim.AnimNode;
import electrosphere.renderer.anim.Animation;
import electrosphere.renderer.loading.ModelPretransforms;
import electrosphere.renderer.model.Bone;
/**
* Used server side to load model data for positioning hitboxes based on animations

8
src/main/java/electrosphere/util/Utilities.java
View File

@ -3,10 +3,10 @@ package electrosphere.util;
import electrosphere.engine.Globals;
import electrosphere.engine.Main;
import electrosphere.logger.LoggerInterface;
import electrosphere.renderer.Material;
import electrosphere.renderer.Mesh;
import electrosphere.renderer.Model;
import electrosphere.renderer.ShaderProgram;
import electrosphere.renderer.model.Material;
import electrosphere.renderer.model.Mesh;
import electrosphere.renderer.model.Model;
import electrosphere.renderer.shader.ShaderProgram;
import electrosphere.renderer.texture.Texture;
import electrosphere.renderer.texture.TextureMap;
import com.google.gson.Gson;