Posted by Sweck on Apr 02, 2020; 7:21pm
URL: https://forum.jogamp.org/Jogl-and-JavaFX-tp4040468p4040488.html

Important are just start() and initCanvas() the rest is just opengl stuff and as I said works perfectly when I use GLCanvas inside a JFrame.


package Testing;

import javax.swing.SwingUtilities;

import com.jogamp.newt.javafx.NewtCanvasJFX;
import com.jogamp.newt.opengl.GLWindow;
import com.jogamp.opengl.GL4;
import com.jogamp.opengl.GLAutoDrawable;
import com.jogamp.opengl.GLCapabilities;
import com.jogamp.opengl.GLContext;
import com.jogamp.opengl.GLEventListener;
import com.jogamp.opengl.GLProfile;
import com.jogamp.opengl.awt.GLJPanel;
import com.jogamp.opengl.util.FPSAnimator;

import Engine.Core.Config;
import Engine.Core.Camera.Camera;
import Engine.Core.Lights.AmbientLight;
import Engine.Core.Lights.DirectionalLight;
import Engine.Core.Math.Matrix4f;
import Engine.Core.Math.Vector3f;
import Engine.Core.Models.Model;
import Engine.Core.Renderer.Renderer;
import Engine.Core.Shaders.Core.BasicShader;
import Engine.Core.Shaders.Core.Material;
import javafx.application.Application;
import javafx.embed.swing.SwingNode;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class Main extends Application implements GLEventListener{

        private boolean experimental = false;
        private GLJPanel canvas;
        private StackPane root;
        private SwingNode swingNode;
       
        private FPSAnimator animator;
        private Renderer renderer;
        private BasicShader shader;
        private Camera camera;
        private Matrix4f projectionMatrix;
        private Model teapot;
         
        public static void main(String[] args) {
          launch(args);
        }
       
       
        @Override
        public void start(Stage primaryStage) throws Exception{
                root = new StackPane();
               
                primaryStage.setTitle("JavaFX OpenGL");
                primaryStage.setScene(new Scene(root, 1920, 1080));
                primaryStage.show();
                initCanvas();
                 
        }
       
        public void initCanvas() {
                final GLProfile glProfile = GLProfile.getDefault();
                final GLCapabilities capabilities = new GLCapabilities(glProfile);
               
               
                if(experimental) {
                        //trying NewtCanvasJFX
                       
            GLWindow glWindow = GLWindow.create(capabilities);
             glWindow.addGLEventListener(this);
           
             NewtCanvasJFX glPanel = new NewtCanvasJFX(glWindow);    
             root.getChildren().add(glPanel);
             
             final FPSAnimator animator = new FPSAnimator(glWindow, 20);
             animator.start();
             
            }else {
            //Using Swing
           
            canvas = new GLJPanel(capabilities);
           
            canvas.addGLEventListener(this);
            swingNode = new SwingNode();
           
            root.getChildren().add(swingNode);
   
            SwingUtilities.invokeLater(new Runnable() {
            public void run() {

            swingNode.setContent(canvas);

            animator = new FPSAnimator(canvas, 20);
              animator.start();
            }
            });
           
                }
        }
       
        @Override
        public void stop() {
                animator.stop();
        }

        @Override
        public void display(GLAutoDrawable arg0) {
               
                renderer.clear();
               
                //teapot.increaseRotation(0,0.5f,0);
               
                renderer.render(teapot, shader);
               
        }

        @Override
        public void dispose(GLAutoDrawable arg0) {

        }

        @SuppressWarnings("unused")
        @Override
        public void init(GLAutoDrawable arg0) {
                Config.BACKGROUND_COLOR = new Vector3f(0.4f,0.5f,0.4f);
               
                projectionMatrix=new Matrix4f();
                projectionMatrix.changeToPerspecitveMatrix(Config.FIELD_OF_VIEW, Config.NEAR_PLANE, Config.FAR_PLANE,canvas.getHeight(),canvas.getWidth());
               
                camera= new Camera(canvas,0,1,5,0,0,0);
               
                renderer = new Renderer(camera,projectionMatrix);
               
                shader=new BasicShader("Phong");
       
            @SuppressWarnings("unused")
                AmbientLight ambientLight = new AmbientLight(1);    
               
                @SuppressWarnings("unused") //new DirectionalLight(lightDirection,        diffuseColor,          speculaColor)
                DirectionalLight directionalLight=new DirectionalLight(new Vector3f(0, 0, -1), new Vector3f(1, 1, 1), new Vector3f(1, 1, 1));
               
                    //new Material(emissionColor,         ambientColor,                 diffuseColor,                 specularColor,                shininess)
                Material basicMaterial = new Material(new Vector3f(0, 0, 0), new Vector3f(0.2f,0.2f,0.2f), new Vector3f(0.5f,0.5f,0.5f), new Vector3f(1.f, 1.f, 1.f), 16);
               
                teapot = new Model("teapot",basicMaterial);
                teapot.setScale(0.8f);
       
        }

        @Override
        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
                GL4 gl=(GL4)GLContext.getCurrentGL();
                gl.glViewport(0, 0, width, height);
                Config.CANVAS_HEIGHT=height;
                Config.CANVAS_WIDTH=width;
                renderer.getProjectionMatrix().changeToPerspecitveMatrix(Config.FIELD_OF_VIEW, Config.NEAR_PLANE, Config.FAR_PLANE,canvas.getHeight(),canvas.getWidth());
                canvas.setSize(width, height);
        }
       
}