Shader.java

package com.mbl111.engine.shaders;

import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL32.*;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.HashMap;

import com.mbl111.engine.Material;
import com.mbl111.engine.Matrix4f;
import com.mbl111.engine.RenderUtil;
import com.mbl111.engine.Util;
import com.mbl111.engine.Vector3f;

public class Shader {

	private int program;
	private HashMap<String, Integer> uniforms;

	public Shader() {
		program = glCreateProgram();
		uniforms = new HashMap<String, Integer>();

		if (program == 0) {
			System.err.println("Shader Creation Failed! No valid memory location found");
			System.exit(1);
		}

	}

	public void bind() {
		glUseProgram(program);
	}

	private static String loadShader(String filename) {
		StringBuilder source = new StringBuilder();
		BufferedReader reader = null;

		try {
			reader = new BufferedReader(new FileReader("./res/shaders/" + filename));

			String line;

			while ((line = reader.readLine()) != null) {
				source.append(line).append("\n");
			}

			reader.close();
		} catch (Exception e) {
			System.err.println("Failed to read shader");
			e.printStackTrace();
			System.exit(1);
		}

		return source.toString();
	}

	public void updateUniforms(Matrix4f worldMatrix, Matrix4f projectedMatrix, Material material) {
	}

	public void setMaterial(Material material) {

	}

	public void addUniform(String uniform) {
		int uniformLocation = glGetUniformLocation(program, uniform);

		if (uniformLocation == 0xFFFFFFFF) {
			System.err.println("Uniform Variable Creation Failed! " + uniform);
			new Exception().printStackTrace();
			System.exit(1);
		}

		uniforms.put(uniform, uniformLocation);
	}

	public void addVertexShaderFromFile(String text) {
		addProgram(loadShader(text), GL_VERTEX_SHADER);
	}

	public void addGeometryShaderFromFile(String text) {
		addProgram(loadShader(text), GL_GEOMETRY_SHADER);
	}

	public void addFragmentShaderFromFile(String text) {
		addProgram(loadShader(text), GL_FRAGMENT_SHADER);
	}

	public void addVertexShader(String text) {
		addProgram(text, GL_VERTEX_SHADER);
	}

	public void addGeometryShader(String text) {
		addProgram(text, GL_GEOMETRY_SHADER);
	}

	public void addFragmentShader(String text) {
		addProgram(text, GL_FRAGMENT_SHADER);
	}

	public void compileShader() {

		glLinkProgram(program);

		if (glGetProgram(program, GL_LINK_STATUS) == 0) {
			System.err.println("Shader Creation Failed!" + glGetShaderInfoLog(program, 1024));
			System.exit(1);
		}

		glValidateProgram(program);

		if (glGetProgram(program, GL_VALIDATE_STATUS) == 0) {
			System.err.println("Shader Creation Failed!" + glGetShaderInfoLog(program, 1024));
			System.exit(1);
		}
	}

	private void addProgram(String text, int type) {
		int shader = glCreateShader(type);

		if (shader == 0) {
			System.err.println("Shader Creation Failed! No valid memory location found while adding shader");
			System.exit(1);
		}

		glShaderSource(shader, text);
		glCompileShader(shader);

		if (glGetShader(shader, GL_COMPILE_STATUS) == 0) {
			System.err.println("Shader Creation Failed!" + glGetShaderInfoLog(shader, 1024));
			System.exit(1);
		}

		glAttachShader(program, shader);

	}

	public void setUniformi(String uniform, int value) {
		glUniform1i(uniforms.get(uniform), value);
	}

	public void setUniformf(String uniform, float value) {
		glUniform1f(uniforms.get(uniform), value);
	}

	public void setUniform(String uniform, Vector3f vec) {
		glUniform3f(uniforms.get(uniform), vec.getX(), vec.getY(), vec.getZ());
	}

	public void setUniform(String uniform, Matrix4f mat) {
		glUniformMatrix4(uniforms.get(uniform), true, Util.createFlippedBuffer(mat));
	}

}