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

Refactoring parts of visual shader class
All checks were successful
studiorailgun/Renderer/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
austin 2024-11-25 15:52:32 -05:00
parent b1230ea07c
commit e204f7ac55
5 changed files with 147 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/src/progress/renderertodo.md
View File

@ -1160,6 +1160,7 @@ Add texture atlasing to blocks
Remove unused import Remove unused import
Geometry mesh generation class Geometry mesh generation class
Cloud shader Cloud shader
VisualShader refactoring
# TODO # TODO

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

@ -647,7 +647,7 @@ public class Globals {
//initialize required windows //initialize required windows
WindowUtils.initBaseWindows(); WindowUtils.initBaseWindows();
//init default shaderProgram //init default shaderProgram
defaultMeshShader = VisualShader.smart_assemble_shader(false,true); defaultMeshShader = VisualShader.smartAssembleShader(false,true);
//init terrain shader program //init terrain shader program
terrainShaderProgram = VisualShader.loadSpecificShader("/Shaders/entities/terrain2/terrain2.vs", "/Shaders/entities/terrain2/terrain2.fs"); terrainShaderProgram = VisualShader.loadSpecificShader("/Shaders/entities/terrain2/terrain2.vs", "/Shaders/entities/terrain2/terrain2.fs");
blockShader = VisualShader.loadSpecificShader("/Shaders/entities/block/block.vs", "/Shaders/entities/block/block.fs"); blockShader = VisualShader.loadSpecificShader("/Shaders/entities/block/block.vs", "/Shaders/entities/block/block.fs");

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

@ -386,7 +386,7 @@ public class RenderUtils {
Material mat = new Material(); Material mat = new Material();
mat.set_diffuse("Textures/color/transparent_teal.png"); mat.set_diffuse("Textures/color/transparent_teal.png");
sphereMesh.setMaterial(mat); sphereMesh.setMaterial(mat);
sphereMesh.setShader(VisualShader.smart_assemble_shader(false, true)); sphereMesh.setShader(VisualShader.smartAssembleShader(false, true));
GL40.glBindVertexArray(0); GL40.glBindVertexArray(0);
sphereMesh.setParent(model); sphereMesh.setParent(model);
model.getMeshes().add(sphereMesh); model.getMeshes().add(sphereMesh);
@ -441,7 +441,7 @@ public class RenderUtils {
Material mat = new Material(); Material mat = new Material();
mat.set_diffuse("Textures/color/transparent_teal.png"); mat.set_diffuse("Textures/color/transparent_teal.png");
sphereMesh.setMaterial(mat); sphereMesh.setMaterial(mat);
sphereMesh.setShader(VisualShader.smart_assemble_shader(false, true)); sphereMesh.setShader(VisualShader.smartAssembleShader(false, true));
GL40.glBindVertexArray(0); GL40.glBindVertexArray(0);
sphereMesh.setParent(model); sphereMesh.setParent(model);
model.getMeshes().add(sphereMesh); model.getMeshes().add(sphereMesh);
@ -528,7 +528,7 @@ public class RenderUtils {
Material mat = new Material(); Material mat = new Material();
mat.set_diffuse("Textures/color/transparent_teal.png"); mat.set_diffuse("Textures/color/transparent_teal.png");
sphereMesh.setMaterial(mat); sphereMesh.setMaterial(mat);
sphereMesh.setShader(VisualShader.smart_assemble_shader(false, true)); sphereMesh.setShader(VisualShader.smartAssembleShader(false, true));
GL40.glBindVertexArray(0); GL40.glBindVertexArray(0);
sphereMesh.setParent(model); sphereMesh.setParent(model);
model.getMeshes().add(sphereMesh); model.getMeshes().add(sphereMesh);

4
src/main/java/electrosphere/renderer/meshgen/MeshLoader.java
View File

@ -331,8 +331,8 @@ public class MeshLoader {
if(!Globals.HEADLESS){ if(!Globals.HEADLESS){
rVal.setShader(VisualShader.smart_assemble_shader(has_bones, apply_lighting)); rVal.setShader(VisualShader.smartAssembleShader(has_bones, apply_lighting));
rVal.setShader(VisualShader.smart_assemble_shader(has_bones, apply_lighting)); rVal.setShader(VisualShader.smartAssembleShader(has_bones, apply_lighting));
rVal.setOITShader(VisualShader.smartAssembleOITProgram(has_bones, apply_lighting)); rVal.setOITShader(VisualShader.smartAssembleOITProgram(has_bones, apply_lighting));
} }

383
src/main/java/electrosphere/renderer/shader/VisualShader.java
View File

@ -1,21 +1,5 @@
package electrosphere.renderer.shader; package electrosphere.renderer.shader;
import static org.lwjgl.opengl.GL11.GL_TRUE;
import static org.lwjgl.opengl.GL20.GL_COMPILE_STATUS;
import static org.lwjgl.opengl.GL20.GL_FRAGMENT_SHADER;
import static org.lwjgl.opengl.GL20.GL_LINK_STATUS;
import static org.lwjgl.opengl.GL20.GL_VERTEX_SHADER;
import static org.lwjgl.opengl.GL20.glAttachShader;
import static org.lwjgl.opengl.GL20.glCompileShader;
import static org.lwjgl.opengl.GL20.glCreateShader;
import static org.lwjgl.opengl.GL20.glDeleteShader;
import static org.lwjgl.opengl.GL20.glGetProgramInfoLog;
import static org.lwjgl.opengl.GL20.glGetProgrami;
import static org.lwjgl.opengl.GL20.glGetShaderi;
import static org.lwjgl.opengl.GL20.glLinkProgram;
import static org.lwjgl.opengl.GL20.glShaderSource;
import static org.lwjgl.opengl.GL32.GL_GEOMETRY_SHADER;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.FileReader; import java.io.FileReader;
import java.io.IOException; import java.io.IOException;
@ -27,7 +11,6 @@ import java.util.Map;
import javax.management.RuntimeErrorException; import javax.management.RuntimeErrorException;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL40; import org.lwjgl.opengl.GL40;
import electrosphere.engine.Globals; import electrosphere.engine.Globals;
@ -37,31 +20,44 @@ import electrosphere.renderer.RenderingEngine;
import electrosphere.util.FileUtils; import electrosphere.util.FileUtils;
/** /**
* A shader program * A visual shader program
*/ */
public class VisualShader implements Shader { public class VisualShader implements Shader {
// /**
//Program stuff * The vertex shader location
// */
int vertexShader; int vertexShader;
int geometryShader;
/**
* The fragment shader location
*/
int fragmentShader; int fragmentShader;
/**
* The shader's ID
*/
int shaderId; int shaderId;
//
//Uniform locations
//
/**
//Uniforms * The map of uniform location -> current value of uniform
*/
public Map<Integer,Object> uniformMap = new HashMap<Integer,Object>(); public Map<Integer,Object> uniformMap = new HashMap<Integer,Object>();
//keeps track of programs that have already been compiled and returns them instead of recompiling from scratch /**
* The map of path -> already compiled shader
*/
static Map<String,VisualShader> alreadyCompiledMap = new HashMap<String,VisualShader>(); static Map<String,VisualShader> alreadyCompiledMap = new HashMap<String,VisualShader>();
public static VisualShader smart_assemble_shader(boolean ContainsBones, boolean apply_lighting){ /**
* Smart assembles a shader
* @param ContainsBones true if the mesh contains bones
* @param apply_lighting true if lighting should be applied
* @return The visual shader
*/
public static VisualShader smartAssembleShader(boolean ContainsBones, boolean apply_lighting){
//return shader if it has already been compiled //return shader if it has already been compiled
String shaderKey = ContainsBones + "-" + apply_lighting; String shaderKey = ContainsBones + "-" + apply_lighting;
@ -122,50 +118,50 @@ public class VisualShader implements Shader {
} }
String fragmentShaderSource = tempForReadingShaders; String fragmentShaderSource = tempForReadingShaders;
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL20.GL_VERTEX_SHADER); rVal.vertexShader = GL40.glCreateShader(GL40.GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource); GL40.glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader); GL40.glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
int success; int success;
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.vertexShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.vertexShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.vertexShader)));
} }
//Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); rVal.fragmentShader = GL40.glCreateShader(GL40.GL_FRAGMENT_SHADER);
//This points the opengl shadder object to its proper source //This points the opengl shadder object to its proper source
glShaderSource(rVal.fragmentShader, fragmentShaderSource); GL40.glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//This compiles the shader object //This compiles the shader object
glCompileShader(rVal.fragmentShader); GL40.glCompileShader(rVal.fragmentShader);
//This tests for the success of the compile attempt //This tests for the success of the compile attempt
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.fragmentShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.fragmentShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.fragmentShader)));
} }
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderId = GL40.glCreateProgram(); rVal.shaderId = GL40.glCreateProgram();
//This attaches the vertex and fragment shaders to the program //This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderId, rVal.vertexShader); GL40.glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader); GL40.glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway) //This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderId); GL40.glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation //Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS); success = GL40.glGetProgrami(rVal.shaderId, GL40.GL_LINK_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId)); throw new RuntimeException(GL40.glGetProgramInfoLog(rVal.shaderId));
} }
//Deletes the individual shader objects to free up memory //Deletes the individual shader objects to free up memory
glDeleteShader(rVal.vertexShader); GL40.glDeleteShader(rVal.vertexShader);
glDeleteShader(rVal.fragmentShader); GL40.glDeleteShader(rVal.fragmentShader);
@ -242,50 +238,50 @@ public class VisualShader implements Shader {
} }
String fragmentShaderSource = tempForReadingShaders; String fragmentShaderSource = tempForReadingShaders;
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL20.GL_VERTEX_SHADER); rVal.vertexShader = GL40.glCreateShader(GL40.GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource); GL40.glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader); GL40. glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
int success; int success;
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.vertexShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.vertexShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.vertexShader)));
} }
//Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); rVal.fragmentShader = GL40.glCreateShader(GL40.GL_FRAGMENT_SHADER);
//This points the opengl shadder object to its proper source //This points the opengl shadder object to its proper source
glShaderSource(rVal.fragmentShader, fragmentShaderSource); GL40.glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//This compiles the shader object //This compiles the shader object
glCompileShader(rVal.fragmentShader); GL40.glCompileShader(rVal.fragmentShader);
//This tests for the success of the compile attempt //This tests for the success of the compile attempt
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.fragmentShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.fragmentShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.fragmentShader)));
} }
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderId = GL40.glCreateProgram(); rVal.shaderId = GL40.glCreateProgram();
//This attaches the vertex and fragment shaders to the program //This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderId, rVal.vertexShader); GL40.glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader); GL40.glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway) //This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderId); GL40. glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation //Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS); success = GL40.glGetProgrami(rVal.shaderId, GL40.GL_LINK_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId)); throw new RuntimeException(GL40.glGetProgramInfoLog(rVal.shaderId));
} }
//Deletes the individual shader objects to free up memory //Deletes the individual shader objects to free up memory
glDeleteShader(rVal.vertexShader); GL40.glDeleteShader(rVal.vertexShader);
glDeleteShader(rVal.fragmentShader); GL40.glDeleteShader(rVal.fragmentShader);
@ -295,7 +291,11 @@ public class VisualShader implements Shader {
} }
public static VisualShader load_default_shader_program(){ /**
* Loads the default shader program
* @return The default shader
*/
public static VisualShader loadDefaultShaderProgram(){
// //
@ -343,56 +343,62 @@ public class VisualShader implements Shader {
} }
String fragmentShaderSource = tempForReadingShaders; String fragmentShaderSource = tempForReadingShaders;
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); rVal.vertexShader = GL40.glCreateShader(GL40.GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource); GL40.glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader); GL40.glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
int success; int success;
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.vertexShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.vertexShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.vertexShader)));
} }
//Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); rVal.fragmentShader = GL40.glCreateShader(GL40.GL_FRAGMENT_SHADER);
//This points the opengl shadder object to its proper source //This points the opengl shadder object to its proper source
glShaderSource(rVal.fragmentShader, fragmentShaderSource); GL40.glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//This compiles the shader object //This compiles the shader object
glCompileShader(rVal.fragmentShader); GL40.glCompileShader(rVal.fragmentShader);
//This tests for the success of the compile attempt //This tests for the success of the compile attempt
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.fragmentShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!"); LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: "); LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader)); LoggerInterface.loggerRenderer.WARNING(GL40.glGetShaderSource(rVal.fragmentShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader))); LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL40.glGetShaderInfoLog(rVal.fragmentShader)));
} }
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderId = GL40.glCreateProgram(); rVal.shaderId = GL40.glCreateProgram();
//This attaches the vertex and fragment shaders to the program //This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderId, rVal.vertexShader); GL40.glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader); GL40.glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway) //This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderId); GL40.glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation //Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS); success = GL40.glGetProgrami(rVal.shaderId, GL40.GL_LINK_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId)); throw new RuntimeException(GL40.glGetProgramInfoLog(rVal.shaderId));
} }
//Deletes the individual shader objects to free up memory //Deletes the individual shader objects to free up memory
glDeleteShader(rVal.vertexShader); GL40.glDeleteShader(rVal.vertexShader);
glDeleteShader(rVal.fragmentShader); GL40.glDeleteShader(rVal.fragmentShader);
return rVal; return rVal;
} }
/**
* Loads a specific shader
* @param vertexPath The vertex shader's path
* @param fragmentPath The fragment shader's path
* @return The visual shader
*/
public static VisualShader loadSpecificShader(String vertexPath, String fragmentPath){ public static VisualShader loadSpecificShader(String vertexPath, String fragmentPath){
VisualShader rVal = new VisualShader(); VisualShader rVal = new VisualShader();
@ -408,28 +414,23 @@ public class VisualShader implements Shader {
} }
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); rVal.vertexShader = GL40.glCreateShader(GL40.GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource); GL40.glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader); GL40.glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
int success; int success;
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.vertexShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
List<Object> errorLines = new LinkedList<Object>(); List<Object> errorLines = new LinkedList<Object>();
LoggerInterface.loggerRenderer.WARNING("Failed to load " + vertexPath + " ... attempting alternatives"); LoggerInterface.loggerRenderer.WARNING("Failed to load " + vertexPath + " ... attempting alternatives");
//report failed to load shader //report failed to load shader
errorLines.add("Vertex Shader failed to compile!"); errorLines.add("Vertex Shader failed to compile!");
errorLines.add("Source File is: " + vertexPath); errorLines.add("Source File is: " + vertexPath);
errorLines.add("Source is: "); errorLines.add("Source is: ");
errorLines.add(GL20.glGetShaderSource(rVal.vertexShader)); errorLines.add(GL40.glGetShaderSource(rVal.vertexShader));
errorLines.add(new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader))); errorLines.add(new RuntimeException(GL40.glGetShaderInfoLog(rVal.vertexShader)));
// LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
// LoggerInterface.loggerRenderer.WARNING("Source File is: " + vertexPath);
// LoggerInterface.loggerRenderer.WARNING("Source is: ");
// LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader));
// LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)));
//attempt loading alternative shaders //attempt loading alternative shaders
List<String> availableAlternatives = Globals.shaderOptionMap.getAlternativesForFile(vertexPath); List<String> availableAlternatives = Globals.shaderOptionMap.getAlternativesForFile(vertexPath);
int alternativesAttempted = 0; int alternativesAttempted = 0;
@ -443,30 +444,25 @@ public class VisualShader implements Shader {
LoggerInterface.loggerEngine.ERROR("Failed to load shader alternative " + alternative, e); LoggerInterface.loggerEngine.ERROR("Failed to load shader alternative " + alternative, e);
} }
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER); rVal.vertexShader = GL40.glCreateShader(GL40.GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource); GL40.glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader); GL40.glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.vertexShader, GL40.GL_COMPILE_STATUS);
if (success == GL_TRUE) { if (success == GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Successfully loaded alternative shader " + alternative); LoggerInterface.loggerRenderer.WARNING("Successfully loaded alternative shader " + alternative);
break; break;
} else { } else {
errorLines.add("Vertex Shader failed to compile!"); errorLines.add("Vertex Shader failed to compile!");
errorLines.add("Source File is: " + vertexPath); errorLines.add("Source File is: " + vertexPath);
errorLines.add("Source is: "); errorLines.add("Source is: ");
errorLines.add(GL20.glGetShaderSource(rVal.vertexShader)); errorLines.add(GL40.glGetShaderSource(rVal.vertexShader));
errorLines.add(new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader))); errorLines.add(new RuntimeException(GL40.glGetShaderInfoLog(rVal.vertexShader)));
// LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
// LoggerInterface.loggerRenderer.WARNING("Source File is: " + vertexPath);
// LoggerInterface.loggerRenderer.WARNING("Source is: ");
// LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader));
// LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)));
} }
} }
if(success != GL_TRUE){ if(success != GL40.GL_TRUE){
for(Object object : errorLines){ for(Object object : errorLines){
if(object instanceof String){ if(object instanceof String){
LoggerInterface.loggerRenderer.WARNING((String)object); LoggerInterface.loggerRenderer.WARNING((String)object);
@ -479,27 +475,22 @@ public class VisualShader implements Shader {
} }
} }
//Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader //Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); rVal.fragmentShader = GL40.glCreateShader(GL40.GL_FRAGMENT_SHADER);
//This points the opengl shadder object to its proper source //This points the opengl shadder object to its proper source
glShaderSource(rVal.fragmentShader, fragmentShaderSource); GL40.glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//This compiles the shader object //This compiles the shader object
glCompileShader(rVal.fragmentShader); GL40.glCompileShader(rVal.fragmentShader);
//This tests for the success of the compile attempt //This tests for the success of the compile attempt
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.fragmentShader, GL40.GL_COMPILE_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
List<Object> errorLines = new LinkedList<Object>(); List<Object> errorLines = new LinkedList<Object>();
LoggerInterface.loggerRenderer.WARNING("Failed to load " + fragmentPath + " ... attempting alternatives"); LoggerInterface.loggerRenderer.WARNING("Failed to load " + fragmentPath + " ... attempting alternatives");
//report failed to load shader //report failed to load shader
errorLines.add("Fragment Shader failed to compile!"); errorLines.add("Fragment Shader failed to compile!");
errorLines.add("Source File is: " + fragmentPath); errorLines.add("Source File is: " + fragmentPath);
errorLines.add("Source is: "); errorLines.add("Source is: ");
errorLines.add(GL20.glGetShaderSource(rVal.fragmentShader)); errorLines.add(GL40.glGetShaderSource(rVal.fragmentShader));
errorLines.add(new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader))); errorLines.add(new RuntimeException(GL40.glGetShaderInfoLog(rVal.fragmentShader)));
// LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
// LoggerInterface.loggerRenderer.WARNING("Source File is: " + fragmentPath);
// LoggerInterface.loggerRenderer.WARNING("Source is: ");
// LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader));
// LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
//attempt loading alternative shaders //attempt loading alternative shaders
List<String> availableAlternatives = Globals.shaderOptionMap.getAlternativesForFile(fragmentPath); List<String> availableAlternatives = Globals.shaderOptionMap.getAlternativesForFile(fragmentPath);
int alternativesAttempted = 0; int alternativesAttempted = 0;
@ -513,30 +504,25 @@ public class VisualShader implements Shader {
LoggerInterface.loggerEngine.ERROR("Failed to load shader alternative " + alternative, e); LoggerInterface.loggerEngine.ERROR("Failed to load shader alternative " + alternative, e);
} }
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader" //Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); rVal.fragmentShader = GL40.glCreateShader(GL40.GL_FRAGMENT_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source //This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.fragmentShader, fragmentShaderSource); GL40.glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//Compiles the source for the vertex shader object //Compiles the source for the vertex shader object
glCompileShader(rVal.fragmentShader); GL40.glCompileShader(rVal.fragmentShader);
//The following tests if the vertex shader compiles successfully //The following tests if the vertex shader compiles successfully
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS); success = GL40.glGetShaderi(rVal.fragmentShader, GL40.GL_COMPILE_STATUS);
if (success == GL_TRUE) { if (success == GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Successfully loaded alternative shader " + alternative); LoggerInterface.loggerRenderer.WARNING("Successfully loaded alternative shader " + alternative);
break; break;
} else { } else {
errorLines.add("Fragment Shader failed to compile!"); errorLines.add("Fragment Shader failed to compile!");
errorLines.add("Source File is: " + fragmentPath); errorLines.add("Source File is: " + fragmentPath);
errorLines.add("Source is: "); errorLines.add("Source is: ");
errorLines.add(GL20.glGetShaderSource(rVal.fragmentShader)); errorLines.add(GL40.glGetShaderSource(rVal.fragmentShader));
errorLines.add(new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader))); errorLines.add(new RuntimeException(GL40.glGetShaderInfoLog(rVal.fragmentShader)));
// LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
// LoggerInterface.loggerRenderer.WARNING("Source File is: " + fragmentPath);
// LoggerInterface.loggerRenderer.WARNING("Source is: ");
// LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader));
// LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.fragmentShader)));
} }
} }
if(success != GL_TRUE){ if(success != GL40.GL_TRUE){
for(Object object : errorLines){ for(Object object : errorLines){
if(object instanceof String){ if(object instanceof String){
LoggerInterface.loggerRenderer.WARNING((String)object); LoggerInterface.loggerRenderer.WARNING((String)object);
@ -551,117 +537,28 @@ public class VisualShader implements Shader {
//This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram //This creates a shader program opengl object and assigns its 'pointer' to the integer shaderProgram
rVal.shaderId = GL40.glCreateProgram(); rVal.shaderId = GL40.glCreateProgram();
//This attaches the vertex and fragment shaders to the program //This attaches the vertex and fragment shaders to the program
glAttachShader(rVal.shaderId, rVal.vertexShader); GL40.glAttachShader(rVal.shaderId, rVal.vertexShader);
glAttachShader(rVal.shaderId, rVal.fragmentShader); GL40.glAttachShader(rVal.shaderId, rVal.fragmentShader);
//This links the program to the GPU (I think its to the GPU anyway) //This links the program to the GPU (I think its to the GPU anyway)
glLinkProgram(rVal.shaderId); GL40.glLinkProgram(rVal.shaderId);
//Tests for the success of the shader program creation //Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS); success = GL40.glGetProgrami(rVal.shaderId, GL40.GL_LINK_STATUS);
if (success != GL_TRUE) { if (success != GL40.GL_TRUE) {
LoggerInterface.loggerRenderer.ERROR(glGetProgramInfoLog(rVal.shaderId), new RuntimeException(glGetProgramInfoLog(rVal.shaderId))); LoggerInterface.loggerRenderer.ERROR(GL40.glGetProgramInfoLog(rVal.shaderId), new RuntimeException(GL40.glGetProgramInfoLog(rVal.shaderId)));
LoggerInterface.loggerRenderer.WARNING("Shader sources: " + vertexPath + " " + fragmentPath); LoggerInterface.loggerRenderer.WARNING("Shader sources: " + vertexPath + " " + fragmentPath);
return Globals.defaultMeshShader; return Globals.defaultMeshShader;
// throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram)); // throw new RuntimeException(glGetProgramInfoLog(rVal.shaderProgram));
} }
//Deletes the individual shader objects to free up memory //Deletes the individual shader objects to free up memory
glDeleteShader(rVal.vertexShader); GL40.glDeleteShader(rVal.vertexShader);
glDeleteShader(rVal.fragmentShader); GL40.glDeleteShader(rVal.fragmentShader);
Globals.renderingEngine.checkError(); Globals.renderingEngine.checkError();
return rVal; return rVal;
} }
public static VisualShader loadSpecificShader(String vertexPath, String geometryPath, String fragmentPath){
VisualShader rVal = new VisualShader();
//
//Read in shader programs
//
String vertexShaderSource = "";
String geometryShaderSource = "";
String fragmentShaderSource = "";
try {
vertexShaderSource = FileUtils.getAssetFileAsString(vertexPath);
geometryShaderSource = FileUtils.getAssetFileAsString(geometryPath);
fragmentShaderSource = FileUtils.getAssetFileAsString(fragmentPath);
} catch(IOException ex){
}
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.vertexShader = glCreateShader(GL_VERTEX_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.vertexShader, vertexShaderSource);
//Compiles the source for the vertex shader object
glCompileShader(rVal.vertexShader);
//The following tests if the vertex shader compiles successfully
int success;
success = glGetShaderi(rVal.vertexShader, GL_COMPILE_STATUS);
if (success != GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Vertex Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.vertexShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.vertexShader)));
}
//Creates a new shader object and assigns its 'pointer' to the integer "vertexShader"
rVal.geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
//This alerts openGL to the presence of a vertex shader and points the shader at its source
glShaderSource(rVal.geometryShader, geometryShaderSource);
//Compiles the source for the vertex shader object
glCompileShader(rVal.geometryShader);
//The following tests if the vertex shader compiles successfully
success = glGetShaderi(rVal.geometryShader, GL_COMPILE_STATUS);
if (success != GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Geometry Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.geometryShader));
LoggerInterface.loggerRenderer.ERROR("Runtime Exception", new RuntimeException(GL20.glGetShaderInfoLog(rVal.geometryShader)));
}
//Creates and opengl object for a fragment shader and assigns its 'pointer' to the integer fragmentShader
rVal.fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
//This points the opengl shadder object to its proper source
glShaderSource(rVal.fragmentShader, fragmentShaderSource);
//This compiles the shader object
glCompileShader(rVal.fragmentShader);
//This tests for the success of the compile attempt
success = glGetShaderi(rVal.fragmentShader, GL_COMPILE_STATUS);
if (success != GL_TRUE) {
LoggerInterface.loggerRenderer.WARNING("Fragment Shader failed to compile!");
LoggerInterface.loggerRenderer.WARNING("Source is: ");
LoggerInterface.loggerRenderer.WARNING(GL20.glGetShaderSource(rVal.fragmentShader));
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.shaderId = GL40.glCreateProgram();
//This attaches the vertex and fragment shaders to the program
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.shaderId);
//Tests for the success of the shader program creation
success = glGetProgrami(rVal.shaderId, GL_LINK_STATUS);
if (success != GL_TRUE) {
throw new RuntimeException(glGetProgramInfoLog(rVal.shaderId));
}
//Deletes the individual shader objects to free up memory
glDeleteShader(rVal.vertexShader);
glDeleteShader(rVal.geometryShader);
glDeleteShader(rVal.fragmentShader);
return rVal;
}
/** /**