View difference between Paste ID: f9d1maes and GYgQjhfg

 // This code has been "de-Java-fyed", though if readability suffers too much, you can ask me to simply reupload the whole java class
 
 int error;
 
 print("Load Shader:");
 
 /* Request two Shader IDs, one typed with GL_VERTEX_SHADER, one with GL_FRAGMENT_SHADER
  * The vertex shader calculates the position of each vertex onscreen, the fragment shader, or pixel shader,
  * calculates the color of each pixel
  */
 
 vertexShaderID = loadShader("res/shader/vs.glsl" , GL_VERTEX_SHADER);
 fragmentShaderID = loadShader("res/shader/fs.glsl", GL_FRAGMENT_SHADER);
 
 /* Request a ProgramID that links the vertex and fragment shader together */
 
 spriteProgramID = glCreateProgram();
 
 /* Attach the shaders to the program */
 
 glAttachShader(spriteProgramID, spriteVertexShaderID);
 glAttachShader(spriteProgramID, spriteHueFragmentShaderID);
 
 /* Compile/Link and validate the program */
 
 glLinkProgram(this.spriteProgramID);
 glValidateProgram(this.spriteProgramID);
 
 if((error = glGetError()) != 0){
 	print("Error after validation: " + error);
 } else {
 	print("Validation completed without errors");
 }
 
 /* Create two buffers, one for character, one for integers: after calling glGetProgramInfoLog, within the character buffer,
  * you will find the text of the error message, within the integer buffer, you will find the length of each line of the error message
  * The allocation functions depend on your programming language - either way, the glGetProgramInfoLog requests pointers
  */
 cbuffer = allocateByteBuffer(512);
 ibuffer = allocateIntBuffer(16);
 
 glGetProgramInfoLog(spriteProgramID, 512, ibuffer, cbuffer);
 
 /* Write the error message on screen */
 
 int c = 0;
 boolean written = false;
 for(int i = 0 ; i < 16 ; i++){
 	for(int j = ibuffer[i] ; j > 0 ; j--){
 		char l = (char) cbuffer[c];
 		c++;
 		print(l);
 		written = true;
 	}
 	if(written){
 		newLine();
 		written = false;
 	}
 }
 
 /* Get the validation status of the program - the integer representing that will be written into an integer buffer (again, the function
  * requests a pointer) */
 
 glGetProgramiv(spriteProgramID, GL_VALIDATE_STATUS, ID_BUFFER);
 
 error = ID_BUFFER[0];
 
 if(error == 0){
 	print("Validation: Error");
 } else if(error == 1){
 	print("Validation: OK!");
 } else {
 	print("Validation: Unknown Error");
 }
 
 /* Now that our program is usable, we bind it to our OpenGL context */
 
 glUseProgram(spriteProgramID);
 
 /* If your program uses Uniform variables, we can request a pointer ID (also called "location") from the program, that links to the
  * value of the variable */
 
 uniformLoc = glGetUniformLocation(spriteProgramID, "uniformVariableName");
 
 if((error = glGetError()) != 0){
 	print("Error after getting Uniform Locations: "+ error);
 } else {
 	print("Uniform Locations received");
 }
 
 /* To get the pointer to an input variable, we use glGetAttribLocation to get a pointer ID to that parameter */
 
 attributeLoc = glGetAttribLocation(spriteProgramID, "attributeVariableName");
 
 if((error = glGetError()) != 0){
 	print("Error after getting attribute locations: "+ error);
 } else {
 	print("Attribute Locations received");
 }
 
 /* I have actually forgotten why I do this */
 
 glBindAttribLocation(spriteProgramID, 0, "attributeVariableName");
 
 print("Created Program");
 
 /* Now we set up the vertices of our object, in this example: a rectangle */
 
 float[] vertices = {
 		0f, 0f,
 		0f, 1f,
 		1f, 1f,
 		1f, 0f,
 		};
 
 /* OpenGL wants it's data input in reverse, so we need to flip the buffer after it is initialzed */
 
 vBuffer = allocateFloats(vertices.length);
 vBuffer.put(vertices);
 vBuffer.flip();
 
 /* Now we create another buffer that contains the information in what order we want to use the given vertices to draw triangles - a
  * rectangle contains two triangles, so we set up this index buffer*/
 
 byte[] indices = {
 		0, 1, 2
 		2, 3, 0
 		};
 
 iBuffer = allocateByteBuffer(indices.length);
 iBuffer.put(indices);
 iBuffer.flip();
 
 /* Now we request a VertexArrayObject and as always, we get an ID*/
 
 vaoID = createVertexArray(gl);
 print("New VAO: " + vaoID);
 
 /* Into this VertexArrayObject we want to put two VertexBufferObjects, one for the vertices, one for the indices */
 
 vboID = createBufferObject();
 System.out.println("New VBO: " + vboID);
 vboiID = createBufferObject();
 System.out.println("New VBO: " + vboiID);
 
 if((error = glGetError()) != 0){
 	print("Error after setting up VAO or VBA: "+ error);
 } else {
 	print("VBA and VBOs created");
 }
 
 /* Bind VAO */
 glBindVertexArray(this.vaoID);
 /* Bind VBO - this adds the VBO to the VAO */
 glBindBuffer(GL_ARRAY_BUFFER, this.vboID);
 /* Enable linking the just bound VBO to the input of a shader - that means whatever is within this buffer is used as an input value
  * to the shader program */
 glEnableVertexAttribArray(attributeLoc);
 /* glVertexAttribPointer(idOfVariable, size of each element, type of each element, normalizing, stride, offset*/
 glVertexAttribPointer(attributeLoc, 2, GL_FLOAT, false, 0, 0L);
 /* Buffer Data into the Buffer - glBufferData(whereToBufferTo, lengthOfDataTypeInBytes, pointerToBuffer,
  * whenToUse) (1 Float = 4 Bytes)
  */
 glBufferData(GL_ARRAY_BUFFER, vertices.length * 4, vBuffer, GL_STATIC_DRAW);
 /* Bind EBO - this adds the EBO to the VAO (The EBO is the Index Buffer)*/
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboiID);
 /* Buffer Data into the Buffer */
 glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.length, iBuffer, GL_STATIC_DRAW);
 /* UnBind for safety reasons ... */
 glBindVertexArray(0);
 
 if((error = glGetError()) != 0){
 	print("Error after setting up the VAO: "+ error);
 } else {
 	print("VAO successfully set up");
-print("Renderer initialized!");
+
 
 print("Renderer initialized!");
 
 /* Subroutine to load a shader */
 int loadShader(String file, int shaderType){
         /* depending on your programming language, simply read out the source code of your .glsl file and save it within a string */
 	string = readFile(file);
 
 	shaderID = glCreateShader(shaderType);
 	print("New Shader ID: "+ shaderID);
         /* attach the source code to the shader - it strangely needs a string array, though each line of a shader's code is simply
          * seperated with \n within the string itself
          */
 	glShaderSource(shaderID, 1, new string[] {string}, null);
 	glCompileShader(shaderID);
 
 	cbuffer = allocateCharacterBuffer(512);
 	ibuffer = allocateIntegerBuffer(16);
 	glGetShaderInfoLog(shaderID, 512, ibuffer, cbuffer);
 	int c = 0;
 	boolean written = false;
 	for(int i = 0 ; i < 16 ; i++){
 		for(int j = ibuffer[i] ; j > 0 ; j--){
 			char l = cbuffer[c];
 			c++;
 			print(l);
 			written = true;
 		}
 		if(written){
 			newLine();
 			written = false;
 		}
 	}
 	return shaderID;
 }
 
 	private int createVertexArray(){
 		glGenVertexArrays(1, ID_BUFFER);
 		return ID_BUFFER[0];
 	}
 
 	private int createBufferObject(GL2 gl){
 		glGenBuffers(1, ID_BUFFER);
 		return ID_BUFFER[0];
 	}