GLProfile glProfile = GLProfile.getMaxFixedFunc(true);
GLCapabilities glCapabilities = new GLCapabilities(glProfile);

GLAutoDrawable dummyDrawable = GLDrawableFactory.getFactory(glProfile).createDummyAutoDrawable(null, true, glCapabilities, null);
dummyDrawable.display();

GLContext ctx = dummyDrawable.getContext();
ctx.makeCurrent();

import java.awt.Point;

import org.eclipse.fx.drift.DriftFXSurface;
import org.eclipse.fx.drift.GLRenderer;
import org.eclipse.fx.drift.PresentationMode;
import org.eclipse.fx.drift.RenderTarget;
import org.eclipse.fx.drift.Renderer;
import org.eclipse.fx.drift.StandardTransferTypes;
import org.eclipse.fx.drift.Swapchain;
import org.eclipse.fx.drift.SwapchainConfig;
import org.eclipse.fx.drift.TransferType;
import org.eclipse.fx.drift.Vec2i;

import com.jogamp.opengl.GL;
import com.jogamp.opengl.GL2;
import com.jogamp.opengl.GLAutoDrawable;
import com.jogamp.opengl.GLCapabilities;
import com.jogamp.opengl.GLContext;
import com.jogamp.opengl.GLDrawableFactory;
import com.jogamp.opengl.GLException;
import com.jogamp.opengl.GLProfile;
import com.jogamp.opengl.glu.GLU;

import it.elman.utils.Utils;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;



public class TestJOGL extends Application {
	
	private static final TransferType transferType = StandardTransferTypes.MainMemory;
	
	private static GLContext glContext;
	
	private static Thread renderThread;
	
	private static Renderer renderer;
	
	private static Swapchain swapchain;
	
	private static int[] fboIDs = new int[1];
	
	private static int[] renderTextureIDs = new int[1];
	
	private static Vec2i lastSize;
	
	private static Long lastResizeTime;
	
	private static BorderPane borderPane;
	
	private static float minX = -100;
	
	private static float maxX = 100;
	
	private static float minY = -100;
	
	private static float maxY = 100;
	
	private static Point lastMousePoint;
	
	
	public static void main(String[] args) {
		launch(args);
	}
	
	
	@Override
	public void start(Stage primaryStage) throws Exception {
		initialize();
		
		DriftFXSurface surface = new DriftFXSurface();
		renderer = GLRenderer.getRenderer(surface);
		
		borderPane = new BorderPane(surface);
		
		borderPane.setOnMouseMoved(event -> {
			
			if(lastMousePoint != null) {
				lastMousePoint.x = (int)event.getX();
				lastMousePoint.y = (int)event.getY();
			}
			else {
				lastMousePoint = new Point((int)event.getX(), (int)event.getY());
			}
			
		});
		
		borderPane.setOnMouseDragged(event -> {
			float xDrag = - (float) ((event.getX() - lastMousePoint.x)*(maxX - minX)/borderPane.widthProperty().floatValue());
			float yDrag = (float) ((event.getY() - lastMousePoint.y)*(maxY - minY)/borderPane.heightProperty().floatValue());
			
			lastMousePoint.x = (int)event.getX();
			lastMousePoint.y = (int)event.getY();
			
			if(!event.isSecondaryButtonDown()) {
				minX += xDrag;
				maxX += xDrag;
				minY += yDrag;
				maxY += yDrag;
			}
			
		});
		
		Scene scene = new Scene(borderPane);
		
		Stage stage = new Stage();
		stage.setScene(scene);
		stage.show();
		
		renderThread.start();
	}
	
	
	private static void initialize() {
		GLProfile.initSingleton();
		
		GLProfile glProfile = null;
		
		try {
			glProfile = GLProfile.getMaxFixedFunc(true);
		} catch(GLException ex) {
			ex.printStackTrace();;
		}
		
		if(glProfile == null) {
			glProfile = GLProfile.getMaxFixedFunc(false);
		}
		
		GLCapabilities glCapabilities = new GLCapabilities(glProfile);
		GLAutoDrawable dummyDrawable = GLDrawableFactory.getFactory(glProfile).createDummyAutoDrawable(null, true, glCapabilities, null);
		dummyDrawable.display();
		glContext = dummyDrawable.getContext();
		
		System.out.println("GL Profile: " + glProfile.getImplName());
		System.out.println("GL VERSION: " + glContext.getGLVersion());
		
		renderThread = new Thread("Render Thread") {
			
			@Override
			public void run() {
				
				try {
				
					while(true) {
						display();
						Thread.sleep(1);
					}
				
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
			
		};
		
		renderThread.setDaemon(true);
	}
	
	
	private static void display() {
		glContext.makeCurrent();
		
		if(fboIDs[0] == 0) {
			createFBO();
		}
		
		checkSwapchain();
		
		try {
		
			if(swapchain != null && lastResizeTime == null) {
				RenderTarget target = swapchain.acquire();
				
				renderTextureIDs[0] = GLRenderer.getGLTextureId(target);
				
				attachFBOToTexture();
				
				bindFBO();
					
				render();
				
				unbindFBO();
				
				swapchain.present(target);
			}
		
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		glContext.release();
	}
	
	
	private static void checkSwapchain() {
		long now = Utils.getNowInMillis();
		Vec2i size = renderer.getSize();
		
		if(size.x > 0 && size.y > 0) {
			
			if(lastSize == null || size.x != lastSize.x || size.y != lastSize.y) {
				lastResizeTime = now;
			}
			
		}
		
		lastSize = size;
		
		if(lastResizeTime != null && (now - lastResizeTime) > 100) {
			
			if (swapchain != null) {
				swapchain.dispose();
			}
			
			renderTextureIDs[0] = 0;
			
			swapchain = renderer.createSwapchain(new SwapchainConfig(size, 2, PresentationMode.MAILBOX, transferType));
			
			lastResizeTime = null;
		}
		
	}
	
	
	private static void createFBO() {
		GL2 gl = glContext.getGL().getGL2();
		gl.glGenFramebuffers(1, fboIDs, 0);
	}
	
	
	private static void attachFBOToTexture() {
		GL2 gl = glContext.getGL().getGL2();
		
		if(fboIDs[0] != 0 && renderTextureIDs[0] != 0) {
			gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, fboIDs[0]);
				
			gl.glFramebufferTexture2D(GL2.GL_FRAMEBUFFER, GL2.GL_COLOR_ATTACHMENT0, GL2.GL_TEXTURE_2D, renderTextureIDs[0], 0);
			
			int tError = gl.glCheckFramebufferStatus(GL2.GL_FRAMEBUFFER);
			
			switch(tError) {
			
				case GL.GL_FRAMEBUFFER_COMPLETE:
					break;
					
				case GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
					break;
					
				case GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
					break;
					
				case GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
					break;
					
				case GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT=GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT");
					break;
					
				case GL2.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER");
					break;
					
				case GL2.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER");
					break;
					
				case GL.GL_FRAMEBUFFER_UNSUPPORTED:
					System.err.println("FRAMEBUFFEROBJECT CHECK RESULT = GL_FRAMEBUFFER_UNSUPPORTED");
					break;
					
				default:
					System.err.println("FRAMEBUFFER CHECK RETURNED UNKNOWN RESULT ...");
					break;
			}
				
			gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, 0);
		}
		
	}
	
	
	private static void bindFBO() {
		GL2 gl = glContext.getGL().getGL2();
		gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, fboIDs[0]);
	}
	
	
	private static void unbindFBO() {
		GL2 gl = glContext.getGL().getGL2();
		gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, 0);
	}
	
	
	private static void render() {
		GL2 gl = glContext.getGL().getGL2();
		GLU glu = new GLU();
		
		gl.glViewport(0, 0, borderPane.widthProperty().intValue(), borderPane.heightProperty().intValue());
		
		gl.glMatrixMode(GL2.GL_PROJECTION);
		gl.glLoadIdentity();
		
		glu.gluOrtho2D(minX, maxX, minY, maxY);
		
		gl.glMatrixMode(GL2.GL_MODELVIEW);
		gl.glLoadIdentity();
		
		gl.glColorMask(true, true, true, true);
		gl.glClearColor(0f, 0f, 0f, 1f);
		gl.glClear(GL.GL_COLOR_BUFFER_BIT);
		gl.glColorMask(true, true, true, false);
		
		gl.glColor3f(0.6f, 0.6f, 0.6f);
		
		gl.glBegin( GL2.GL_QUADS);
			gl.glVertex3f(-90f, -90f, 0);
			gl.glVertex3f(-90f, 90f, 0);
			gl.glVertex3f(90f, 90f, 0);
			gl.glVertex3f(90f, -90f, 0);
		gl.glEnd();
	}


}