858 lines
34 KiB
Java
858 lines
34 KiB
Java
package electrosphere.renderer;
|
|
|
|
import electrosphere.entity.CameraEntityUtils;
|
|
import electrosphere.main.Globals;
|
|
import electrosphere.main.Main;
|
|
import electrosphere.renderer.light.LightBuffer;
|
|
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 org.joml.Matrix4f;
|
|
import org.joml.Vector3f;
|
|
import org.lwjgl.BufferUtils;
|
|
import org.lwjgl.PointerBuffer;
|
|
import org.lwjgl.assimp.AIBone;
|
|
import org.lwjgl.assimp.AIFace;
|
|
import org.lwjgl.assimp.AIMesh;
|
|
import org.lwjgl.assimp.AIVector2D;
|
|
import org.lwjgl.assimp.AIVector3D;
|
|
import org.lwjgl.assimp.AIVertexWeight;
|
|
import static org.lwjgl.opengl.ARBVertexBufferObject.*;
|
|
import org.lwjgl.opengl.GL11;
|
|
import static org.lwjgl.opengl.GL11.GL_FALSE;
|
|
import static org.lwjgl.opengl.GL11.GL_FLOAT;
|
|
import static org.lwjgl.opengl.GL11.GL_INT;
|
|
import static org.lwjgl.opengl.GL11.GL_TRIANGLES;
|
|
import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT;
|
|
import org.lwjgl.opengl.GL15;
|
|
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
|
|
import static org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER;
|
|
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
|
|
import static org.lwjgl.opengl.GL15.glBindBuffer;
|
|
import static org.lwjgl.opengl.GL15.glGenBuffers;
|
|
import org.lwjgl.opengl.GL20;
|
|
import static org.lwjgl.opengl.GL20.*;
|
|
import static org.lwjgl.opengl.GL20.glGetUniformLocation;
|
|
import static org.lwjgl.opengl.GL20.glUniform1i;
|
|
import static org.lwjgl.opengl.GL20.glUniform3fv;
|
|
import static org.lwjgl.opengl.GL20.glUniformMatrix4fv;
|
|
import static org.lwjgl.opengl.GL20.glUseProgram;
|
|
import static org.lwjgl.opengl.GL20.glVertexAttribPointer;
|
|
import static org.lwjgl.opengl.GL30.glBindVertexArray;
|
|
import static org.lwjgl.opengl.GL30.glGenVertexArrays;
|
|
|
|
/**
|
|
*
|
|
* @author satellite
|
|
*/
|
|
public class Mesh {
|
|
public Model parent;
|
|
public String nodeID;
|
|
public AIMesh mesh;
|
|
public int vertexBuffer;
|
|
public int normalBuffer;
|
|
public int elementArrayBuffer;
|
|
public int elementCount;
|
|
public int faceCount;
|
|
public int vertexArrayObject;
|
|
public int vertexCount;
|
|
public int normalCount;
|
|
public int boneWeightBuffer;
|
|
public int boneIndexBuffer;
|
|
public int boneCount;
|
|
public int textureCoordBuffer;
|
|
public int textureCoordCount;
|
|
public ArrayList<Bone> bones = new ArrayList();
|
|
public ArrayList<String> bone_id_list = new ArrayList();
|
|
HashMap<String,Object> uniforms = new HashMap();
|
|
int bone_map_size = 0;
|
|
boolean hasBones = true;
|
|
public boolean hasTextureCoords = true;
|
|
|
|
public List<Texture> textureList;
|
|
public boolean useTextureList;
|
|
public String textureListArrayUniformName;
|
|
|
|
public float vertexMinX;
|
|
public float vertexMaxX;
|
|
public float vertexMinY;
|
|
public float vertexMaxY;
|
|
public float vertexMinZ;
|
|
public float vertexMaxZ;
|
|
|
|
public ShaderProgram shader;
|
|
|
|
int shaderBoneArrayLocation;
|
|
|
|
Material material;
|
|
|
|
LightBuffer light_buffer;
|
|
|
|
public static Mesh create_mesh_from_aimesh(AIMesh mesh){
|
|
boolean has_bones = false;
|
|
boolean apply_lighting = true;
|
|
|
|
Mesh rVal = new Mesh();
|
|
rVal.mesh = mesh;
|
|
|
|
//
|
|
// VAO
|
|
//
|
|
rVal.vertexArrayObject = glGenVertexArrays();
|
|
glBindVertexArray(rVal.vertexArrayObject);
|
|
|
|
|
|
|
|
//Basic checks
|
|
//check num vertices
|
|
int numVertices = 0;
|
|
AIVector3D.Buffer vertexData = mesh.mVertices();
|
|
while(vertexData.hasRemaining()){
|
|
vertexData.get();
|
|
numVertices++;
|
|
}
|
|
vertexData = vertexData.rewind();
|
|
//check num normals
|
|
int numNormals = 0;
|
|
AIVector3D.Buffer normalData = mesh.mNormals();
|
|
while(normalData.hasRemaining()){
|
|
normalData.get();
|
|
numNormals++;
|
|
}
|
|
normalData.rewind();
|
|
if(numVertices != numNormals){
|
|
System.out.println("Catastrophic failure: Number of vertices =/= Number of normals");
|
|
System.exit(1);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//Buffer data to GPU
|
|
//
|
|
vertexData.rewind();
|
|
|
|
try {
|
|
rVal.vertexCount = mesh.mNumVertices();
|
|
FloatBuffer VertexArrayBufferData = BufferUtils.createFloatBuffer(rVal.vertexCount * 3);
|
|
float[] temp = new float[3];
|
|
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();
|
|
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;
|
|
}
|
|
temp[0] = x;
|
|
temp[1] = y;
|
|
temp[2] = 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.convertAIMatrix(currentBoneData.mOffsetMatrix());
|
|
currentBone.numWeights = currentBoneData.mNumWeights();
|
|
currentBone.weights = new HashMap();
|
|
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;
|
|
} else if(boneVal > weight[1]){
|
|
weight[3] = weight[2];
|
|
weight[2] = weight[1];
|
|
weight[1] = boneVal;
|
|
index[3] = index[2];
|
|
index[2] = index[1];
|
|
index[1] = boneCounter;
|
|
} else if(boneVal > weight[2]){
|
|
weight[3] = weight[2];
|
|
weight[2] = boneVal;
|
|
index[3] = index[2];
|
|
index[2] = boneCounter;
|
|
} else if(boneVal > weight[3]){
|
|
weight[3] = boneVal;
|
|
index[3] = boneCounter;
|
|
}
|
|
}
|
|
boneCounter++;
|
|
}
|
|
float total = weight[0] + weight[1] + weight[2] + weight[3];
|
|
if(total != 1.0f){
|
|
weight[0] = weight[0] * (1.0f / total);
|
|
weight[1] = weight[1] * (1.0f / total);
|
|
weight[2] = weight[2] * (1.0f / total);
|
|
weight[3] = weight[3] * (1.0f / total);
|
|
}
|
|
boneIndexDataBuffer.put(index);
|
|
boneWeightDataBuffer.put(weight);
|
|
}
|
|
boneIndexDataBuffer.flip();
|
|
boneWeightDataBuffer.flip();
|
|
|
|
|
|
rVal.boneWeightBuffer = glGenBuffers();
|
|
glBindBuffer(GL_ARRAY_BUFFER, rVal.boneWeightBuffer);
|
|
GL15.glBufferData(GL_ARRAY_BUFFER, boneWeightDataBuffer, GL_STATIC_DRAW);
|
|
glVertexAttribPointer(2, 4, GL_FLOAT, false, 0, 0);
|
|
glEnableVertexAttribArray(2);
|
|
|
|
|
|
rVal.boneIndexBuffer = glGenBuffers();
|
|
glBindBuffer(GL_ARRAY_BUFFER, rVal.boneIndexBuffer);
|
|
GL15.glBufferData(GL_ARRAY_BUFFER, boneIndexDataBuffer, GL_STATIC_DRAW);
|
|
glVertexAttribPointer(3, 4, GL_FLOAT, false, 0, 0);
|
|
glEnableVertexAttribArray(3);
|
|
} else {
|
|
rVal.hasBones = false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
rVal.shader = ShaderProgram.smart_assemble_shader(has_bones, apply_lighting);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
glBindVertexArray(0);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
rVal.nodeID = mesh.mName().dataString();
|
|
|
|
|
|
return rVal;
|
|
}
|
|
|
|
|
|
public Mesh(){
|
|
|
|
}
|
|
|
|
// public void draw() {
|
|
// glUseProgram(shader.shaderProgram);
|
|
//
|
|
// //Until we switch to uniform buffer objects we will have to buffer lighting data here manually each time we draw
|
|
// //side note: :(
|
|
// if(light_buffer == null){
|
|
// float temp[] = new float[3];
|
|
// temp[0] = 0.2f;
|
|
// temp[1] = -1.0f;
|
|
// temp[2] = 0.3f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.direction"), temp);
|
|
//
|
|
// temp[0] = 0.1f;
|
|
// temp[1] = 0.1f;
|
|
// temp[2] = 0.1f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.ambient"), temp);
|
|
//
|
|
// temp[0] = 0.8f;
|
|
// temp[1] = 0.8f;
|
|
// temp[2] = 0.8f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.diffuse"), temp);
|
|
//
|
|
// temp[0] = 0.1f;
|
|
// temp[1] = 0.1f;
|
|
// temp[2] = 0.1f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.specular"), temp);
|
|
//
|
|
// temp[0] = 32f;
|
|
// glUniform1fv(glGetUniformLocation(shader.shaderProgram, "material.shininess"), temp);
|
|
//
|
|
// GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
//
|
|
// Vector3f cam_Loc = CameraEntityUtils.getCameraEye(Globals.playerCamera);//Globals.cameraVisible.pos_Center;
|
|
// temp[0] = cam_Loc.x;
|
|
// temp[1] = cam_Loc.y;
|
|
// temp[2] = cam_Loc.z;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "viewPos"), temp);
|
|
// } else {
|
|
// GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
// }
|
|
//
|
|
//
|
|
// if(material == null){
|
|
// Globals.materialDefault.apply_material(0,1);
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 0);
|
|
// } else {
|
|
// material.apply_material();
|
|
// if(material.hasTransparency){
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1);
|
|
// } else {
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1);
|
|
// }
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
// glBindVertexArray(vertexArrayObject);
|
|
//
|
|
//
|
|
// glActiveTexture(GL_TEXTURE3);
|
|
// glBindTexture(GL_TEXTURE_2D, Globals.shadowMapTextureLoc);
|
|
// glUniform1i(glGetUniformLocation(shader.shaderProgram, "shadowMap"), 3);
|
|
//
|
|
//
|
|
//
|
|
// //
|
|
// //Handle bones
|
|
// //
|
|
// if(bones != null && !bones.isEmpty()){
|
|
// glUniform1i(shader.shaderVertexHasBonesLoc, 1);
|
|
// glUniform1i(shader.shaderVertexNumBonesLoc, bones.size());
|
|
// Iterator<String> boneIterator = bone_id_list.iterator();
|
|
// float bufferarray[] = new float[16];
|
|
// int incrementer = 0;
|
|
// while (boneIterator.hasNext()){
|
|
// Bone currentBone = parent.boneMap.get(boneIterator.next());
|
|
// Matrix4f currentMat = new Matrix4f(currentBone.final_transform);
|
|
// currentMat.get(bufferarray);
|
|
// String currentUniform = "bones[" + incrementer + "]";
|
|
// GL20.glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, currentUniform), false, bufferarray);
|
|
// incrementer++;
|
|
// }
|
|
// } else {
|
|
// glUniform1i(shader.shaderVertexHasBonesLoc, 0);
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
// //buffer model/view/proj matrices
|
|
// glUniformMatrix4fv(shader.shaderVertexModelLoc, false, parent.modelMatrix.get(new float[16]));
|
|
// glUniformMatrix4fv(shader.shaderVertexViewLoc, false, Globals.viewMatrix.get(new float[16]));
|
|
// glUniformMatrix4fv(shader.shaderVertexProjectionLoc, false, Globals.projectionMatrix.get(new float[16]));
|
|
// glUniform3fv(shader.shaderVertexViewPosLoc, CameraEntityUtils.getCameraEye(Globals.playerCamera).get(BufferUtils.createFloatBuffer(3)));
|
|
// glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
|
|
//
|
|
// //
|
|
// //
|
|
// //Testing Lights
|
|
// //
|
|
// //
|
|
// float test_Light_Data[] = new float[3];
|
|
// test_Light_Data[0] = 0.2f;
|
|
// test_Light_Data[1] = -1.0f;
|
|
// test_Light_Data[2] = 0.3f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.direction"), test_Light_Data);
|
|
//
|
|
// test_Light_Data = new float[3];
|
|
// test_Light_Data[0] = 0.3f;
|
|
// test_Light_Data[1] = 0.3f;
|
|
// test_Light_Data[2] = 0.3f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.ambient"), test_Light_Data);
|
|
//
|
|
// test_Light_Data = new float[3];
|
|
// test_Light_Data[0] = 0.5f;
|
|
// test_Light_Data[1] = 0.5f;
|
|
// test_Light_Data[2] = 0.5f;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "dirLight.diffuse"), test_Light_Data);
|
|
//
|
|
// Vector3f cam_Loc = CameraEntityUtils.getCameraEye(Globals.playerCamera);
|
|
// test_Light_Data = new float[3];
|
|
// test_Light_Data[0] = cam_Loc.x;
|
|
// test_Light_Data[1] = cam_Loc.y;
|
|
// test_Light_Data[2] = cam_Loc.z;
|
|
// glUniform3fv(glGetUniformLocation(shader.shaderProgram, "viewPos"), test_Light_Data);
|
|
//
|
|
//
|
|
// GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
|
|
// glBindVertexArray(0);
|
|
// }
|
|
|
|
public void buffer_vertices(FloatBuffer verticies, int vertexDimension){
|
|
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){
|
|
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){
|
|
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){
|
|
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){
|
|
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){
|
|
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 setTextureList(List<Texture> textureList, String uniformName){
|
|
this.textureList = textureList;
|
|
useTextureList = true;
|
|
textureListArrayUniformName = uniformName;
|
|
}
|
|
|
|
public void set_material(Material input){
|
|
this.material = input;
|
|
}
|
|
|
|
|
|
// public void drawForDepthBuffer(){
|
|
// /*
|
|
//
|
|
// !!!!!!!!!!!!!!!!!THERE IS NO SHADER PROGRAM HERE!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
//
|
|
// The shader program is set in the main render function to make things easier
|
|
//
|
|
// */
|
|
//
|
|
//
|
|
// glBindVertexArray(vertexArrayObject);
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// //
|
|
// //Handle bones
|
|
// //
|
|
// if(bones != null && !bones.isEmpty()){
|
|
// glUniform1i(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "numBones"), bones.size());
|
|
// glUniform1i(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "hasBones"), 1);
|
|
// Iterator<String> boneIterator = bone_id_list.iterator();
|
|
// float bufferarray[] = new float[16];
|
|
// int incrementer = 0;
|
|
// while (boneIterator.hasNext()){
|
|
// Bone currentBone = parent.boneMap.get(boneIterator.next());
|
|
// Matrix4f currentMat = new Matrix4f(currentBone.final_transform);
|
|
// currentMat.get(bufferarray);
|
|
// String currentUniform = "bones[" + incrementer + "]";
|
|
// GL20.glUniformMatrix4fv(glGetUniformLocation(Globals.depthMapShaderProgramLoc, currentUniform), false, bufferarray);
|
|
// incrementer++;
|
|
// }
|
|
// } else {
|
|
// glUniform1i(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "hasBones"), 0);
|
|
// }
|
|
//
|
|
// //buffer model/view/proj matrices
|
|
// glUniformMatrix4fv(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
// glUniformMatrix4fv(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
|
|
//
|
|
//
|
|
// GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
|
|
// glBindVertexArray(0);
|
|
// }
|
|
|
|
// public void drawUI(){
|
|
// glUseProgram(shader.shaderProgram);
|
|
//
|
|
// glBindVertexArray(vertexArrayObject);
|
|
//
|
|
// if(material == null){
|
|
// Globals.materialDefault.apply_material(0,1);
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 0);
|
|
// } else {
|
|
// material.apply_material();
|
|
// if(material.hasTransparency){
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1);
|
|
// } else {
|
|
// GL20.glUniform1i(glGetUniformLocation(shader.shaderProgram, "hasTransparency"), 1);
|
|
// }
|
|
// }
|
|
//
|
|
// //buffers contents of uniforms map to gpu
|
|
// bufferAllUniforms();
|
|
//
|
|
// glUniformMatrix4fv(glGetUniformLocation(shader.shaderProgram, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
//
|
|
// GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
|
|
// glBindVertexArray(0);
|
|
// }
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void complexDraw(boolean setShader, boolean bufferStandardUniforms, boolean bufferNonStandardUniforms, boolean useMaterial, boolean useShadowMap, boolean setBones, boolean useLight){
|
|
if(setShader){
|
|
Globals.renderingEngine.setActiveShader(shader);
|
|
}
|
|
|
|
if(useLight){
|
|
//Until we switch to uniform buffer objects we will have to buffer lighting data here manually each time we draw
|
|
//side note: :(
|
|
if(light_buffer == null){
|
|
float temp[] = new float[3];
|
|
temp[0] = 0.2f;
|
|
temp[1] = -1.0f;
|
|
temp[2] = 0.3f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.direction"), temp);
|
|
|
|
temp[0] = 0.1f;
|
|
temp[1] = 0.1f;
|
|
temp[2] = 0.1f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.ambient"), temp);
|
|
|
|
temp[0] = 0.8f;
|
|
temp[1] = 0.8f;
|
|
temp[2] = 0.8f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.diffuse"), temp);
|
|
|
|
temp[0] = 0.1f;
|
|
temp[1] = 0.1f;
|
|
temp[2] = 0.1f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.specular"), temp);
|
|
|
|
temp[0] = 32f;
|
|
glUniform1fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "material.shininess"), temp);
|
|
|
|
GL20.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
|
|
Vector3f cam_Loc = CameraEntityUtils.getCameraEye(Globals.playerCamera);//Globals.cameraVisible.pos_Center;
|
|
temp[0] = cam_Loc.x;
|
|
temp[1] = cam_Loc.y;
|
|
temp[2] = cam_Loc.z;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "viewPos"), temp);
|
|
} else {
|
|
GL20.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
}
|
|
}
|
|
|
|
if(useMaterial && !useTextureList){
|
|
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"), 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(useTextureList){
|
|
for(Texture texture : textureList){
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
glBindVertexArray(vertexArrayObject);
|
|
|
|
if(useShadowMap){
|
|
glActiveTexture(GL_TEXTURE3);
|
|
glBindTexture(GL_TEXTURE_2D, Globals.shadowMapTextureLoc);
|
|
glUniform1i(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "shadowMap"), 3);
|
|
}
|
|
|
|
|
|
if(setBones){
|
|
//
|
|
//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()){
|
|
Bone currentBone = parent.boneMap.get(boneIterator.next());
|
|
Matrix4f currentMat = new Matrix4f(currentBone.final_transform);
|
|
currentMat.get(bufferarray);
|
|
String currentUniform = "bones[" + incrementer + "]";
|
|
GL20.glUniformMatrix4fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, currentUniform), false, bufferarray);
|
|
incrementer++;
|
|
}
|
|
} else {
|
|
glUniform1i(Globals.renderingEngine.getActiveShader().shaderVertexHasBonesLoc, 0);
|
|
}
|
|
}
|
|
|
|
|
|
if(bufferStandardUniforms){
|
|
//buffer model/view/proj matrices
|
|
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]));
|
|
}
|
|
|
|
if(bufferNonStandardUniforms){
|
|
bufferAllUniforms();
|
|
}
|
|
|
|
// if(shadowMapShader){
|
|
// glUniformMatrix4fv(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "model"), false, parent.modelMatrix.get(new float[16]));
|
|
// glUniformMatrix4fv(glGetUniformLocation(Globals.depthMapShaderProgramLoc, "lightSpaceMatrix"), false, Globals.lightDepthMatrix.get(new float[16]));
|
|
// }
|
|
|
|
if(useLight){
|
|
//
|
|
//
|
|
//Testing Lights
|
|
//
|
|
//
|
|
float test_Light_Data[] = new float[3];
|
|
test_Light_Data[0] = 0.2f;
|
|
test_Light_Data[1] = -1.0f;
|
|
test_Light_Data[2] = 0.3f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.direction"), test_Light_Data);
|
|
|
|
test_Light_Data = new float[3];
|
|
test_Light_Data[0] = 0.3f;
|
|
test_Light_Data[1] = 0.3f;
|
|
test_Light_Data[2] = 0.3f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.ambient"), test_Light_Data);
|
|
|
|
test_Light_Data = new float[3];
|
|
test_Light_Data[0] = 0.5f;
|
|
test_Light_Data[1] = 0.5f;
|
|
test_Light_Data[2] = 0.5f;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "dirLight.diffuse"), test_Light_Data);
|
|
|
|
Vector3f cam_Loc = CameraEntityUtils.getCameraEye(Globals.playerCamera);
|
|
test_Light_Data = new float[3];
|
|
test_Light_Data[0] = cam_Loc.x;
|
|
test_Light_Data[1] = cam_Loc.y;
|
|
test_Light_Data[2] = cam_Loc.z;
|
|
glUniform3fv(glGetUniformLocation(Globals.renderingEngine.getActiveShader().shaderProgram, "viewPos"), test_Light_Data);
|
|
}
|
|
|
|
|
|
|
|
GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0);
|
|
glBindVertexArray(0);
|
|
}
|
|
}
|