package electrosphere.renderer.model; import electrosphere.engine.Globals; import electrosphere.entity.types.camera.CameraEntityUtils; import electrosphere.renderer.OpenGLState; import electrosphere.renderer.RenderPipelineState; import electrosphere.renderer.RenderingEngine; 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 static org.lwjgl.opengl.GL11.GL_FLOAT; import static org.lwjgl.opengl.GL11.GL_INT; import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D; import static org.lwjgl.opengl.GL11.GL_TRIANGLES; import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT; import static org.lwjgl.opengl.GL13.GL_TEXTURE3; 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 static org.lwjgl.opengl.GL20.glEnableVertexAttribArray; 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.glVertexAttribPointer; import static org.lwjgl.opengl.GL30.glBindVertexArray; import static org.lwjgl.opengl.GL30.glGenVertexArrays; import org.lwjgl.opengl.GL45; import org.lwjgl.system.MemoryStack; /** * 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; //pulls double duty as both the element array count as well as the direct array count, based on whichever is used private int vertexArrayObject; private int boneWeightBuffer; private int boneIndexBuffer; private int textureCoordBuffer; //uses element instances private boolean useElementArray = true; //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 bones = new ArrayList(); private ArrayList boneIdList = new ArrayList(); //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 uniforms = new HashMap(); //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; } } /** * Sets the number of elements in the directly referenced arrays underneath this mesh * @param directArraySize The number of elements (ie the number of vertices, or normals, etc) */ public void setDirectArraySize(int directArraySize){ this.elementCount = directArraySize; } /** * 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(OpenGLState openGLState){ for(String key : uniforms.keySet()){ Object currentUniformRaw = uniforms.get(key); if(currentUniformRaw instanceof Matrix4f){ Matrix4f currentUniform = (Matrix4f)currentUniformRaw; glUniformMatrix4fv(glGetUniformLocation(openGLState.getActiveShader().getShaderId(), key), false, currentUniform.get(new float[16])); Globals.renderingEngine.checkError(); } if(currentUniformRaw instanceof Vector3f){ Vector3f currentUniform = (Vector3f)currentUniformRaw; glUniform3fv(glGetUniformLocation(openGLState.getActiveShader().getShaderId(), key), currentUniform.get(BufferUtils.createFloatBuffer(3))); Globals.renderingEngine.checkError(); } if(currentUniformRaw instanceof Integer){ int currentInform = (Integer)currentUniformRaw; glUniform1i(glGetUniformLocation(openGLState.getActiveShader().getShaderId(), key), currentInform); Globals.renderingEngine.checkError(); } } } /** * Sends a buffer to the gpu * @param uniformTypeMap The type of the buffer * @param buffers The buffer */ void bufferInstanceData( RenderPipelineState renderPipelineState, Map buffers, Map 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, OpenGLState openGLState){ //bind vao off the rip glBindVertexArray(vertexArrayObject); Globals.renderingEngine.checkError(); if(renderPipelineState.getUseMeshShader()){ ShaderProgram selectedProgram = null; switch(renderPipelineState.getSelectedShader()){ case PRIMARY: { selectedProgram = shader; } break; case OIT: { selectedProgram = oitShader; } break; } if(selectedProgram == null){ selectedProgram = shader; } openGLState.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(openGLState); } Globals.renderingEngine.checkError(); } if(renderPipelineState.getUseMaterial() && textureMask == null){ Globals.renderingEngine.checkError(); if(material == null){ Globals.materialDefault.apply_material(openGLState,0,1); openGLState.getActiveShader().setUniform(openGLState, "hasTransparency", 0); } else { material.apply_material(openGLState); if(material.hasTransparency){ openGLState.getActiveShader().setUniform(openGLState, "hasTransparency", 1); } else { openGLState.getActiveShader().setUniform(openGLState, "hasTransparency", 0); } } Globals.renderingEngine.checkError(); } // //The texture masking logic if(textureMask != null){ // //path that uses already-defined texture objects if(textureMask.getTextures() != null){ int i = 0; for(Texture texture : textureMask.getTextures()){ if(texture != null){ texture.bind(openGLState,5+i); } openGLState.getActiveShader().setUniform(openGLState, textureMask.getUniformNames().get(i), 5+i); i++; } } else if(textureMask.getTexturePaths() != null){ // //path that uses paths to textures in the asset manager int i = 0; for(String texturePath : textureMask.getTexturePaths()){ Texture texture = Globals.assetManager.fetchTexture(texturePath); if(texture != null){ texture.bind(openGLState, i); } i++; } } Globals.renderingEngine.checkError(); } if(renderPipelineState.getUseShadowMap()){ openGLState.glActiveTexture(GL_TEXTURE3); Globals.renderingEngine.checkError(); openGLState.glBindTexture(GL_TEXTURE_2D, RenderingEngine.lightBufferDepthTexture.getTexturePointer()); Globals.renderingEngine.checkError(); openGLState.getActiveShader().setUniform(openGLState, "shadowMap", 3); } if(renderPipelineState.getUseBones()){ // //Handle bones // if(bones != null && !bones.isEmpty()){ openGLState.getActiveShader().setUniform(openGLState, "hasBones", 1); openGLState.getActiveShader().setUniform(openGLState, "numBones", bones.size()); Iterator boneIterator = boneIdList.iterator(); int incrementer = 0; while (boneIterator.hasNext()){ String boneName = boneIterator.next(); Bone currentBone = parent.getBoneMap().get(boneName); String currentUniform = "bones[" + incrementer + "]"; if(currentBone != null){ Matrix4d currentMat = currentBone.getFinalTransform(); openGLState.getActiveShader().setUniform(openGLState, currentUniform, currentMat); } else { openGLState.getActiveShader().setUniform(openGLState, currentUniform, new Matrix4f()); } incrementer++; } } else { openGLState.getActiveShader().setUniform(openGLState, "hasBones", 0); } } else { openGLState.getActiveShader().setUniform(openGLState, "hasBones", 0); } if(renderPipelineState.getBufferStandardUniforms()){ //buffer model/view/proj matrices try(MemoryStack stack = MemoryStack.stackPush()){ openGLState.getActiveShader().setUniform(openGLState, "model", parent.getModelMatrix()); openGLState.getActiveShader().setUniform(openGLState, "view", Globals.viewMatrix); openGLState.getActiveShader().setUniform(openGLState, "projection", Globals.projectionMatrix); openGLState.getActiveShader().setUniform(openGLState, "viewPos", CameraEntityUtils.getCameraEye(Globals.playerCamera)); Vector3f worldPos = new Vector3f((float)parent.getWorldPos().x,(float)parent.getWorldPos().y,(float)parent.getWorldPos().z); openGLState.getActiveShader().setUniform(openGLState, "modelWorldPos", worldPos); openGLState.getActiveShader().setUniform(openGLState, "lightSpaceMatrix", Globals.lightDepthMatrix); openGLState.getActiveShader().setUniform(openGLState, "frame", (int)Globals.timekeeper.getNumberOfRenderFramesElapsed()); openGLState.getActiveShader().setUniform(openGLState, "time", (float)Globals.timekeeper.getCurrentRendererTime()); } Globals.renderingEngine.checkError(); } if(renderPipelineState.getBufferNonStandardUniforms()){ bufferAllUniforms(openGLState); Globals.renderingEngine.checkError(); } if(renderPipelineState.getInstanced()){ if(renderPipelineState.getInstanceData()!=null){ InstanceData instanceData = renderPipelineState.getInstanceData(); Map buffers = instanceData.getCpuBufferMap(); Map glBufferMap = instanceData.getGlBufferMap(); bufferInstanceData(renderPipelineState, buffers, glBufferMap); renderPipelineState.setInstanceCount(instanceData.getDrawCount()); Globals.renderingEngine.checkError(); } } if(renderPipelineState.getInstanced()){ if(elementCount > 0 ){ GL45.glDrawElementsInstanced(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0, renderPipelineState.getInstanceCount()); Globals.renderingEngine.checkError(); } } else { if(useElementArray){ if(elementCount > 0){ GL11.glDrawElements(GL_TRIANGLES, elementCount, GL_UNSIGNED_INT, 0); Globals.renderingEngine.checkError(); } } else { if(elementCount > 0){ GL11.glDrawArrays(GL_TRIANGLES, 0, elementCount); Globals.renderingEngine.checkError(); } } } glBindVertexArray(0); Globals.renderingEngine.checkError(); } /** * 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 getBones(){ return bones; } /** * Sets the bones for this mesh * @param bones The list of bones */ public void setBones(List bones){ this.bones = bones; } /** * Registers a bone id * @param boneId the bone id */ public void registerBoneId(String boneId){ this.boneIdList.add(boneId); } /** * Sets whether to use an element array or a direct array * @param useElementArray if true, use elements, else use direct array reference */ public void setUseElementArray(boolean useElementArray){ this.useElementArray = useElementArray; } /** * Gets whether the mesh uses an element array or a direct array * @return if true, use elements, else use direct array reference */ public boolean getUseElementArray(){ return this.useElementArray; } /** * Gets the vertex buffer's pointer * @return The vertex buffer's pointer */ public int getVertexBuffer(){ return vertexBuffer; } /** * Gets the normal buffer's pointer * @return The normal buffer's pointer */ public int getNormalBuffer(){ return normalBuffer; } /** * Gets the texture coord buffer's pointer * @return The texture coord buffer's pointer */ public int getTextureCoordBuffer(){ return textureCoordBuffer; } }