jmonkeyengine/jme3-jogl/src/main/java/com/jme3/system/jogl/JoglNewtDisplay.java

/*
 * Copyright (c) 2009-2012 jMonkeyEngine
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.jme3.system.jogl;

import com.jme3.system.AppSettings;
import com.jogamp.newt.MonitorMode;
import com.jogamp.newt.Screen;
import com.jogamp.newt.event.WindowAdapter;
import com.jogamp.newt.event.WindowEvent;
import com.jogamp.newt.util.MonitorModeUtil;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.jogamp.nativewindow.util.Dimension;
import com.jogamp.opengl.GLAutoDrawable;

public class JoglNewtDisplay extends JoglNewtAbstractDisplay {
    
    private static final Logger logger = Logger.getLogger(JoglNewtDisplay.class.getName());

    protected AtomicBoolean windowCloseRequest = new AtomicBoolean(false);
    protected AtomicBoolean needClose = new AtomicBoolean(false);
    protected AtomicBoolean needRestart = new AtomicBoolean(false);
    protected volatile boolean wasInited = false;

    public Type getType() {
        return Type.Display;
    }

    protected void createGLFrame(){
        canvas.setTitle(settings.getTitle());
        
        applySettings(settings);
        
        // Make the window visible to realize the OpenGL surface.
        canvas.setVisible(true);
        
        //this is the earliest safe opportunity to get the context
        //final GLContext context = canvas.getContext();
        
        /*canvas.invoke(true, new GLRunnable() {
            @Override
            public boolean run(GLAutoDrawable glAutoDrawable) {     
                context.makeCurrent();
                try {
                    startGLCanvas();
                }
                finally {
                    context.release();
                }
                return true;
            }
        });*/
    }

    protected void applySettings(AppSettings settings){
        active.set(true);
        canvas.addWindowListener(new WindowAdapter() {
            @Override
            public void windowDestroyNotify(WindowEvent e) {
                windowCloseRequest.set(true);
            }
            
            @Override
            public void windowGainedFocus(WindowEvent e) {
                active.set(true);
            }
            
            @Override
            public void windowLostFocus(WindowEvent e) {
                active.set(false);
            }
        });
        canvas.setSize(settings.getWidth(), settings.getHeight());
        canvas.setUndecorated(settings.isFullscreen());
        canvas.setFullscreen(settings.isFullscreen());
        
        /**
         * uses the filtering relying on resolution with the size to fetch only
         * the screen mode matching with the current resolution
         */
        Screen screen = canvas.getScreen();
        /**
         * The creation of native resources is lazy in JogAmp, i.e they are 
         * created only when they are used for the first time. When the GLWindow
         * is not yet visible, its screen might have been unused for now and 
         * then its native counterpart has not yet been created. That's why 
         * forcing the creation of this resource is necessary
         */
        screen.addReference();
        if (settings.isFullscreen()) {
            List<MonitorMode> screenModes = canvas.getMainMonitor().getSupportedModes();
            //the resolution is provided by the user
            Dimension dimension = new Dimension(settings.getWidth(), settings.getHeight());
            screenModes = MonitorModeUtil.filterByResolution(screenModes, dimension);
            screenModes = MonitorModeUtil.getHighestAvailableBpp(screenModes);
            if (settings.getFrequency() > 0) {
                screenModes = MonitorModeUtil.filterByRate(screenModes, settings.getFrequency());
            } else {
                screenModes = MonitorModeUtil.getHighestAvailableRate(screenModes);
            }
            canvas.getMainMonitor().setCurrentMode(screenModes.get(0));
        }
        
        MonitorMode currentScreenMode = canvas.getMainMonitor().getCurrentMode();
        logger.log(Level.FINE, "Selected display mode: {0}x{1}x{2} @{3}",
                new Object[]{currentScreenMode.getRotatedWidth(),
                             currentScreenMode.getRotatedHeight(),
                             currentScreenMode.getSurfaceSize().getBitsPerPixel(),
                             currentScreenMode.getRefreshRate()});
    }

    private void privateInit(){
        initGLCanvas();

        createGLFrame();

        startGLCanvas();
    }

    public void init(GLAutoDrawable drawable){
        // prevent initializing twice on restart
        if (!wasInited){
            wasInited = true;
            
            canvas.requestFocus();

            super.internalCreate();
            logger.fine("Display created.");

            renderer.initialize();
            listener.initialize();
        }
    }

    public void create(boolean waitFor){
        privateInit();
    }

    public void destroy(boolean waitFor){
        needClose.set(true);
        if (waitFor){
            waitFor(false);
        }
        if (animator.isAnimating())
            animator.stop();
    }

    public void restart() {
        if (created.get()){
            needRestart.set(true);
        }else{
            throw new IllegalStateException("Display not started yet. Cannot restart");
        }
    }

    public void setTitle(String title){
        if (canvas != null) {
            canvas.setTitle(title);
        }
    }

    /**
     * Callback.
     */
    public void display(GLAutoDrawable drawable) {
        if (needClose.get()) {
            listener.destroy();
            animator.stop();
            if (settings.isFullscreen()) {
                canvas.setFullscreen(false);
            }
            canvas.destroy();
            logger.fine("Display destroyed.");
            super.internalDestroy();
            return;
        }

        if (windowCloseRequest.get()){
            listener.requestClose(false);
            windowCloseRequest.set(false);
        }

        if (needRestart.getAndSet(false)){
            // for restarting contexts
            if (canvas.isVisible()){
                animator.stop();
                canvas.destroy();
                createGLFrame();
                startGLCanvas();
            }
        }

//        boolean flush = autoFlush.get();
//        if (animator.isAnimating() != flush){
//            if (flush)
//                animator.stop();
//            else
//                animator.start();
//        }

        if (wasActive != active.get()){
            if (!wasActive){
                listener.gainFocus();
                wasActive = true;
            }else{
                listener.loseFocus();
                wasActive = false;
            }
        }

        listener.update();
        renderer.postFrame();
    }
}