import com.jogamp.newt.opengl.GLWindow;

import com.jogamp.newt.event.WindowEvent;
import com.jogamp.newt.event.WindowListener;
import com.jogamp.newt.event.WindowUpdateEvent;
import com.jogamp.opengl.util.glsl.ShaderCode;
import com.jogamp.opengl.util.glsl.ShaderProgram;

import com.jogamp.opengl.*;
import com.jogamp.opengl.FBObject.*;
import javax.media.opengl.*;

import java.nio.FloatBuffer;

public class FBOTest3 implements GLEventListener, WindowListener{
	
	private final float[] canvasVertices = {
			-1f, -1f, 0.0f,
			-1f, 1f, 0.0f,
			1f, -1f, 0.0f,
			1f,  1f, 0.0f,	
	};
	
	private final float[] canvasTexCoords = {
			0.0f, 0.0f,
			0.0f, 1.0f,
			1.0f, 0.0f,
			1.0f, 1.0f,
	};
	
	private final float[] quadVertices = {
			-0.5f, -0.5f, 0.0f,
			-0.5f, 0.5f, 0.0f,
			0.5f, -0.5f, 0.0f,
			0.5f,  0.5f, 0.0f,	
	};
	
	private final float[] offsetQuadVertices = {
			-1f, -1f, 0.0f,
			-1f, 0f, 0.0f,
			0f, -1f, 0.0f,
			0f, 0f, 0.0f,	
	};
	
	//OpenGL Data
	private GLProfile glProfile;
	private GLCapabilities glCapabilities;
	private GLWindow gameWindow;
	
	//Canvas data
	private ShaderProgram canvasShader;
	private int canvasVAO;
	private int canvasTexture;
	private int canvasColourFramebuffer;
	
	//Object data
	private int vaoCentre;
	private int vaoOffset;
	
	private FBObject source;
	private FBObject target;
	private GL3ES3 gl;
	
	private void initFBO()
	{
		gl = GLContext.getCurrentGL().getGL3ES3();
		source = new FBObject(); // Create FrameBuffer
		
		source.reset(gl, 320, 320); // int width, height - size of FBO, can be resized with the same call
		// With MSAA:
		// fbo.reset(gl, width, height, sampleNum, true); // int width, height, sampleNum - size/sampleNum of FBO, can be resized with the same call
		source.attachTexture2D(gl, 0, true); // Create GL_TEXTURE_2D texture which can be used as sampler2D at the shader code
		// Created texture will be bound to FBO's GL_COLOR_ATTACHMENT0 (see the second parameter 0)
		source.attachRenderbuffer(gl, Attachment.Type.DEPTH, 32); // Create depth buffer (if required)
		source.unbind(gl); // See Note-3 for use with MSAA. Unbind FrameBuffer (You will probably want to make bind() - render - unbind() loop later on)
	}
	
	
	private void renderToFBO()
	{
		source.bind(gl);
		
		// Render scene as usual
		gl.glClearColor(0, 0, 1, 1);
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
		gl.glBindVertexArray(vaoCentre);
		gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, quadVertices.length);
		gl.glBindVertexArray(vaoOffset);
		gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, offsetQuadVertices.length);
		
		source.unbind(gl); // See Note-3 for use with MSAA
	}
	
	public void renderFBOToScreen()
	{
		final TextureAttachment tex0 = (TextureAttachment) source.getColorbuffer(0);
		gl.glActiveTexture(GL2.GL_TEXTURE0);
		gl.glEnable(GL2.GL_TEXTURE_2D);  // Should not call this for CORE profiles, i.e. ES2, GL3, ..
		gl.glBindTexture(GL2.GL_TEXTURE_2D, tex0.getName()); // See Notes 1, 2. Binding source FBO's TextureAttachment as GL_TEXTURE_2D
		// Here you can just render a fullscreen quad to show FBO content, or do something more exciting
		   
		 //Draw the colour buffer to the screen
		gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
		gl.glClearColor(1f, 0f, 0f, 1f);
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
		
		gl.glBindVertexArray(canvasVAO);
		canvasShader.useProgram(gl, true);

        int textureSamplerIndex = gl.glGetUniformLocation(canvasShader.program(), "textureUnit");
		gl.glUniform1f(textureSamplerIndex, 0);
        
        gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, canvasVertices.length/3);
	}
	
	public final void init(GLAutoDrawable glad)
	{
		GL2 gl = glad.getGL().getGL2();
		
		//Load shaders
		canvasShader = loadShader(gl, "Canvas.vsh", "Canvas.fsh");
		
		//Generate framebuffers
		int[] framebuffers = new int[1];
		gl.glGenFramebuffers(2, framebuffers, 0);
		canvasColourFramebuffer = framebuffers[0];
		
		//Generate textures
		int[] textures = new int[1];
		gl.glGenTextures(1, textures, 0);
		canvasTexture = textures[0];
		gl.glBindTexture(GL.GL_TEXTURE_2D, canvasTexture);
		
		//Generate VAOs
		int[] vaos = new int[3];
		gl.glGenVertexArrays(3, vaos, 0);
		vaoCentre = vaos[0];
		vaoOffset = vaos[1];
		canvasVAO = vaos[2];
		
		//Generate buffers
		int[] buffers = new int[4];
		gl.glGenBuffers(4, buffers, 0);
		int vertBuffer = buffers[0];
		int offsetVertBuffer = buffers[1];
		int canvasVertBuffer = buffers[2];
		int canvasTexCoordBuffer = buffers[3];
		
		//Initialize VAOs
		gl.glBindVertexArray(vaoCentre);
		gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertBuffer);
		gl.glBufferData(GL.GL_ARRAY_BUFFER, quadVertices.length*(Float.SIZE/8), FloatBuffer.wrap(quadVertices), GL.GL_STATIC_DRAW);
		gl.glEnableVertexAttribArray(0);
		gl.glVertexAttribPointer(0, 3, GL.GL_FLOAT, false, 0, 0);
		
		gl.glBindVertexArray(vaoOffset);
		gl.glBindBuffer(GL.GL_ARRAY_BUFFER, offsetVertBuffer);
		gl.glBufferData(GL.GL_ARRAY_BUFFER, offsetQuadVertices.length*(Float.SIZE/8), FloatBuffer.wrap(offsetQuadVertices), GL.GL_STATIC_DRAW);
		gl.glEnableVertexAttribArray(0);
		gl.glVertexAttribPointer(0, 3, GL.GL_FLOAT, false, 0, 0);
		
		//Canvas VAO
		canvasShader.useProgram(gl, true);
		gl.glBindVertexArray(canvasVAO);
		gl.glBindBuffer(GL.GL_ARRAY_BUFFER, canvasVertBuffer);
		gl.glBufferData(GL.GL_ARRAY_BUFFER, canvasVertices.length*(Float.SIZE/8), FloatBuffer.wrap(canvasVertices), GL.GL_STATIC_DRAW);
		int positionLoc = gl.glGetAttribLocation(canvasShader.program(), "position");
		gl.glEnableVertexAttribArray(positionLoc);
		gl.glVertexAttribPointer(positionLoc, 3, GL.GL_FLOAT, false, 0, 0);
		
		gl.glBindBuffer(GL.GL_ARRAY_BUFFER, canvasTexCoordBuffer);
		gl.glBufferData(GL.GL_ARRAY_BUFFER, canvasTexCoords.length*(Float.SIZE/8), FloatBuffer.wrap(canvasTexCoords), GL.GL_STATIC_DRAW);
		int texCoordLoc = gl.glGetAttribLocation(canvasShader.program(), "texCoord");
		gl.glEnableVertexAttribArray(texCoordLoc);
		gl.glVertexAttribPointer(texCoordLoc, 2, GL.GL_FLOAT, false, 0, 0);
		canvasShader.useProgram(gl, false);
		
		//Setup the canvas
		gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, canvasColourFramebuffer);
		gl.glBindTexture(GL.GL_TEXTURE_2D, canvasTexture);
		gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, 320, 320, 0, GL.GL_RGB, GL.GL_FLOAT, null);
		
		gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
		gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
		
		gl.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, canvasTexture, 0);
		
		gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
		
		initFBO();
	}
	
	public final void display(GLAutoDrawable glad)
	{
		renderToFBO();
		renderFBOToScreen();
	}
	
	public FBOTest3()
	{
		//Initialize the OpenGL profile that the game will use
		glProfile = GLProfile.getDefault();
		glCapabilities = new GLCapabilities(glProfile);
		
		//Create the game window
		gameWindow = GLWindow.create(glCapabilities);
		gameWindow.setSize(320, 320);
		gameWindow.setVisible(true);
		gameWindow.setTitle("JOGL Test");
		gameWindow.addWindowListener(this);
		gameWindow.addGLEventListener(this);
	}
	
	public final void start()
	{
		while(true)
		{
			gameWindow.display();
		}
	}

	public static void main(String[] args)
	{
		FBOTest3 fbot = new FBOTest3();
		fbot.start();
	}
	
	private ShaderProgram loadShader(GL2 gl, String vertexShader, String fragmentShader)
	{
		ShaderCode vertShader = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, getClass(), new String[]{"/shaders/"+vertexShader},false);
		vertShader.compile(gl);
		
		ShaderCode fragShader = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, getClass(), new String[]{"/shaders/"+fragmentShader},false);
		fragShader.compile(gl);
		
		ShaderProgram newShader = new ShaderProgram();
		newShader.init(gl);
		newShader.add(vertShader);
		newShader.add(fragShader);
		
		newShader.link(gl, System.out);
		
		vertShader.destroy(gl);
		fragShader.destroy(gl);

		return newShader;
	}
	
	//GLEvent listener methods
	public void reshape(GLAutoDrawable glad, int x, int y, int width, int height)
	{
	}
	public void dispose(GLAutoDrawable glad)
	{
	}
	
	//Window listener methods
	public void windowDestroyNotify(WindowEvent we)
	{
		//The window and profile get cleaned up automatically in this case anyways
		System.exit(0);
	}
	public void windowDestroyed(WindowEvent we){}
	public void windowGainedFocus(WindowEvent we){}
	public void windowLostFocus(WindowEvent we){}
	public void windowMoved(WindowEvent we){}
	public void windowResized(WindowEvent we){}
	public void windowRepaint(WindowUpdateEvent wue){}
}