Attachment 25 Details for Bug 100 – Example of "incorrect" order which fails in fullscreen

Example of "incorrect" order which fails in fullscreen

Order.java (text/plain), 15.74 KB, created by Sven Gothel on 2004-07-24 09:44:00 CEST

(hide)

Description:

Filename:

MIME Type:

Creator: Sven Gothel

Created: 2004-07-24 09:44:00 CEST

Size: 15.74 KB

patch

obsolete

>import java.awt.*;
>import java.awt.event.*;
>import javax.swing.*;
>import net.java.games.jogl.*;
>import net.java.games.jogl.util.*;
>
>public class Order
>{
>    private static final int DEFAULT_WIDTH = 640;
>    private static final int DEFAULT_HEIGHT = 480;
>    
>    public static GLDisplay createGLDisplay(String title)
>    {
>        GraphicsDevice device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
>        boolean fullscreen = false;
>        if (device.isFullScreenSupported())
>        {
>            int selectedOption = JOptionPane.showOptionDialog(null,
>                                                              "How would you like to run this lesson?",
>                                                              title,
>                                                              JOptionPane.YES_NO_OPTION,
>                                                              JOptionPane.QUESTION_MESSAGE,
>                                                              null,
>                                                              new Object[]
>                                                              {"Fullscreen", "Windowed"},
>                                                              "Windowed");
>            fullscreen = selectedOption == 0;
>        }
>        return new GLDisplay(title, DEFAULT_WIDTH, DEFAULT_HEIGHT, fullscreen);
>    }
>    
>  public static void main(String[] args)
>  {
>    GLDisplay neheGLDisplay = createGLDisplay("Lesson 05: 3D Shapes");
>    neheGLDisplay.addGLEventListener(new Renderer());
>    neheGLDisplay.start();
>  }
>}
>/** Port of the NeHe OpenGL Tutorial (Lesson 5)
> * to Java using the Jogl interface to OpenGL.  Jogl can be obtained
> * at http://jogl.dev.java.net/
> *
> * @author Kevin Duling (jattier@hotmail.com)
> */
>class Renderer implements GLEventListener
>{
>  private float rquad = 0.0f;
>  private float rtri = 0.0f;
>  
>  /** Called by the drawable to initiate OpenGL rendering by the client.
>   * After all GLEventListeners have been notified of a display event, the
>   * drawable will swap its buffers if necessary.
>   * @param gLDrawable The GLDrawable object.
>   */
>  public void display(GLDrawable gLDrawable)
>  {
>    final GL gl = gLDrawable.getGL();
>    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
>    gl.glLoadIdentity();
>    gl.glTranslatef(-1.5f, 0.0f, -6.0f);
>    gl.glRotatef(rtri, 0.0f, 1.0f, 0.0f);
>    gl.glBegin(GL.GL_TRIANGLES);		    // Drawing Using Triangles
>    gl.glColor3f(1.0f,0.0f,0.0f);			// Red
>    gl.glVertex3f( 0.0f, 1.0f, 0.0f);			// Top Of Triangle (Front)
>    gl.glColor3f(0.0f,1.0f,0.0f);			// Green
>    gl.glVertex3f(-1.0f,-1.0f, 1.0f);			// Left Of Triangle (Front)
>    gl.glColor3f(0.0f,0.0f,1.0f);			// Blue
>    gl.glVertex3f( 1.0f,-1.0f, 1.0f);			// Right Of Triangle (Front)
>    gl.glColor3f(1.0f,0.0f,0.0f);			// Red
>    gl.glVertex3f( 0.0f, 1.0f, 0.0f);			// Top Of Triangle (Right)
>    gl.glColor3f(0.0f,0.0f,1.0f);			// Blue
>    gl.glVertex3f( 1.0f,-1.0f, 1.0f);			// Left Of Triangle (Right)
>    gl.glColor3f(0.0f,1.0f,0.0f);			// Green
>    gl.glVertex3f( 1.0f,-1.0f, -1.0f);			// Right Of Triangle (Right)
>    gl.glColor3f(1.0f,0.0f,0.0f);			// Red
>    gl.glVertex3f( 0.0f, 1.0f, 0.0f);			// Top Of Triangle (Back)
>    gl.glColor3f(0.0f,1.0f,0.0f);			// Green
>    gl.glVertex3f( 1.0f,-1.0f, -1.0f);			// Left Of Triangle (Back)
>    gl.glColor3f(0.0f,0.0f,1.0f);			// Blue
>    gl.glVertex3f(-1.0f,-1.0f, -1.0f);			// Right Of Triangle (Back)
>    gl.glColor3f(1.0f,0.0f,0.0f);			// Red
>    gl.glVertex3f( 0.0f, 1.0f, 0.0f);			// Top Of Triangle (Left)
>    gl.glColor3f(0.0f,0.0f,1.0f);			// Blue
>    gl.glVertex3f(-1.0f,-1.0f,-1.0f);			// Left Of Triangle (Left)
>    gl.glColor3f(0.0f,1.0f,0.0f);			// Green
>    gl.glVertex3f(-1.0f,-1.0f, 1.0f);			// Right Of Triangle (Left)
>    gl.glEnd();				// Finished Drawing The Triangle
>    gl.glLoadIdentity();
>    gl.glTranslatef(1.5f, 0.0f, -6.0f);
>    gl.glRotatef(rquad, 1.0f, 1.0f, 1.0f);
>    gl.glBegin(GL.GL_QUADS);           	// Draw A Quad
>    gl.glColor3f(0.0f,1.0f,0.0f);			// Set The Color To Green
>    gl.glVertex3f( 1.0f, 1.0f,-1.0f);			// Top Right Of The Quad (Top)
>    gl.glVertex3f(-1.0f, 1.0f,-1.0f);			// Top Left Of The Quad (Top)
>    gl.glVertex3f(-1.0f, 1.0f, 1.0f);			// Bottom Left Of The Quad (Top)
>    gl.glVertex3f( 1.0f, 1.0f, 1.0f);			// Bottom Right Of The Quad (Top)
>    
>    gl.glColor3f(1.0f,0.5f,0.0f);			// Set The Color To Orange
>    gl.glVertex3f( 1.0f,-1.0f, 1.0f);			// Top Right Of The Quad (Bottom)
>    gl.glVertex3f(-1.0f,-1.0f, 1.0f);			// Top Left Of The Quad (Bottom)
>    gl.glVertex3f(-1.0f,-1.0f,-1.0f);			// Bottom Left Of The Quad (Bottom)
>    gl.glVertex3f( 1.0f,-1.0f,-1.0f);			// Bottom Right Of The Quad (Bottom)
>    
>    gl.glColor3f(1.0f,0.0f,0.0f);			// Set The Color To Red
>    gl.glVertex3f( 1.0f, 1.0f, 1.0f);			// Top Right Of The Quad (Front)
>    gl.glVertex3f(-1.0f, 1.0f, 1.0f);			// Top Left Of The Quad (Front)
>    gl.glVertex3f(-1.0f,-1.0f, 1.0f);			// Bottom Left Of The Quad (Front)
>    gl.glVertex3f( 1.0f,-1.0f, 1.0f);			// Bottom Right Of The Quad (Front)
>    
>    gl.glColor3f(1.0f,1.0f,0.0f);			// Set The Color To Yellow
>    gl.glVertex3f( 1.0f,-1.0f,-1.0f);			// Bottom Left Of The Quad (Back)
>    gl.glVertex3f(-1.0f,-1.0f,-1.0f);			// Bottom Right Of The Quad (Back)
>    gl.glVertex3f(-1.0f, 1.0f,-1.0f);			// Top Right Of The Quad (Back)
>    gl.glVertex3f( 1.0f, 1.0f,-1.0f);			// Top Left Of The Quad (Back)
>    
>    gl.glColor3f(0.0f,0.0f,1.0f);			// Set The Color To Blue
>    gl.glVertex3f(-1.0f, 1.0f, 1.0f);			// Top Right Of The Quad (Left)
>    gl.glVertex3f(-1.0f, 1.0f,-1.0f);			// Top Left Of The Quad (Left)
>    gl.glVertex3f(-1.0f,-1.0f,-1.0f);			// Bottom Left Of The Quad (Left)
>    gl.glVertex3f(-1.0f,-1.0f, 1.0f);			// Bottom Right Of The Quad (Left)
>    
>    gl.glColor3f(1.0f,0.0f,1.0f);			// Set The Color To Violet
>    gl.glVertex3f( 1.0f, 1.0f,-1.0f);			// Top Right Of The Quad (Right)
>    gl.glVertex3f( 1.0f, 1.0f, 1.0f);			// Top Left Of The Quad (Right)
>    gl.glVertex3f( 1.0f,-1.0f, 1.0f);			// Bottom Left Of The Quad (Right)
>    gl.glVertex3f( 1.0f,-1.0f,-1.0f);			// Bottom Right Of The Quad (Right)
>    gl.glEnd();				// Done Drawing The Quad
>    gl.glFlush();
>    rtri += 0.2f;
>    rquad += 0.15f;
>  }
>
>  /** Called when the display mode has been changed.  <B>!! CURRENTLY UNIMPLEMENTED IN JOGL !!</B>
>   * @param gLDrawable The GLDrawable object.
>   * @param modeChanged Indicates if the video mode has changed.
>   * @param deviceChanged Indicates if the video device has changed.
>   */
>  public void displayChanged(GLDrawable gLDrawable, boolean modeChanged, boolean deviceChanged)
>  {
>  }
>  
>  /** Called by the drawable immediately after the OpenGL context is
>   * initialized for the first time. Can be used to perform one-time OpenGL
>   * initialization such as setup of lights and display lists.
>   * @param gLDrawable The GLDrawable object.
>   */
>  public void init(GLDrawable gLDrawable)
>  {
>    GL gl = gLDrawable.getGL();
>    gl.glShadeModel(GL.GL_SMOOTH);              // Enable Smooth Shading
>    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);    // Black Background
>    gl.glClearDepth(1.0f);                      // Depth Buffer Setup
>    gl.glEnable(GL.GL_DEPTH_TEST);              // Enables Depth Testing
>    gl.glDepthFunc(GL.GL_LEQUAL);		// The Type Of Depth Testing To Do
>    gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);	// Really Nice Perspective Calculations
>    System.out.println();
>    System.out.println("OPENGL DRIVER INFORMATION");
>    System.out.println(" Version: " + gl.glGetString(GL.GL_VERSION));
>    System.out.println("Renderer: " + gl.glGetString(GL.GL_RENDERER));
>    System.out.println("  Vendor: " + gl.glGetString(GL.GL_VENDOR));
>    System.out.println();
>    System.out.println("DISPLAY INFORMATION");
>    Dimension dim = gLDrawable.getSize();
>    System.out.println("Resolution: " + (int)dim.getWidth() + "x" + (int)dim.getHeight());
>    GLCapabilities glCaps = new GLCapabilities();
>    System.out.println(glCaps.toString());
>  }
>  
>  /** Called by the drawable during the first repaint after the component has
>   * been resized. The client can update the viewport and view volume of the
>   * window appropriately, for example by a call to
>   * GL.glViewport(int, int, int, int); note that for convenience the component
>   * has already called GL.glViewport(int, int, int, int)(x, y, width, height)
>   * when this method is called, so the client may not have to do anything in
>   * this method.
>   * @param gLDrawable The GLDrawable object.
>   * @param x The X Coordinate of the viewport rectangle.
>   * @param y The Y coordinate of the viewport rectanble.
>   * @param width The new width of the window.
>   * @param height The new height of the window.
>   */
>  public void reshape(GLDrawable gLDrawable, int x, int y, int width, int height)
>  {
>    final GL gl = gLDrawable.getGL();
>    final GLU glu = gLDrawable.getGLU();
>    
>    if (height <= 0) // avoid a divide by zero error!
>      height = 1;
>    final float h = (float)width / (float)height;
>    gl.glViewport(0, 0, width, height);
>    gl.glMatrixMode(GL.GL_PROJECTION);
>    gl.glLoadIdentity();
>    glu.gluPerspective(45.0f, h, 1.0, 20.0);
>    gl.glMatrixMode(GL.GL_MODELVIEW);
>    gl.glLoadIdentity();
>  }
>}
>class GLDisplay
>{
>    private static final int DEFAULT_WIDTH = 640;
>    private static final int DEFAULT_HEIGHT = 480;
>    
>    private static final int DONT_CARE = -1;
>    
>    private JFrame frame;
>    private GLCanvas glCanvas;
>    private Animator animator;
>    private boolean fullscreen;
>    private int width;
>    private int height;
>    private GraphicsDevice usedDevice;
>    DisplayMode oldDisplayMode;
>    
>    public GLDisplay(String title, boolean fullscreen)
>    {
>        this(title, DEFAULT_WIDTH, DEFAULT_HEIGHT, fullscreen);
>    }
>    
>    public GLDisplay(String title, int width, int height, boolean fullscreen)
>    {
>        GLCapabilities glCaps = new GLCapabilities();
>        boolean hwAccel = glCaps.getHardwareAccelerated();
>        glCanvas = GLDrawableFactory.getFactory().createGLCanvas(glCaps);
>        glCanvas.setSize(width, height);
>        glCanvas.setIgnoreRepaint(true);
>        
>        frame = new JFrame(title);
>        frame.getContentPane().setLayout(new BorderLayout());
>		  //
>		  // Adding the canvas before showing in a fullscreen app
>		  // prior to 1.1b04 (July 16) causes a white screen of death
>        frame.getContentPane().add(glCanvas, BorderLayout.CENTER);
>        
>        addKeyListener(new MyShutdownKeyAdapter());
>        
>        this.fullscreen = fullscreen;
>        this.width = width;
>        this.height = height;
>        animator = new Animator(glCanvas);
>    }
>    
>    public void start()
>    {
>        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
>        frame.setSize(width, height);
>        frame.setLocation((screenSize.width - frame.getWidth()) / 2,
>                                              (screenSize.height - frame.getHeight()) / 2);
>        frame.addWindowListener(new MyShutdownWindowAdapter());
>        
>        if (fullscreen)
>        {
>            frame.setUndecorated(true);
>            usedDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
>            this.oldDisplayMode  = usedDevice.getDisplayMode();
>            usedDevice.setFullScreenWindow(frame);
>            usedDevice.setDisplayMode(findDisplayMode(usedDevice.getDisplayModes(),
>                                                                                                           width, height,
>                                                                                                           usedDevice.getDisplayMode().getBitDepth(),
>                                                                                                           usedDevice.getDisplayMode().getRefreshRate()));
>       } else
>        {
>            frame.setVisible(true);
>        }
>
>		  // Moved the add call to this location to save the virtual world
>        // frame.getContentPane().add(glCanvas, BorderLayout.CENTER);
>        glCanvas.requestFocus();
>        
>        animator.start();
>    }
>    
>    public void stop()
>    {
>        animator.stop();
>        if (fullscreen)
>        {
>            usedDevice.setDisplayMode(oldDisplayMode);
>            usedDevice.setFullScreenWindow(null);
>            usedDevice = null;
>        }
>        frame.dispose();
>        System.exit(0);
>    }
>    
>    private DisplayMode findDisplayMode(DisplayMode[] displayModes, int requestedWidth, int requestedHeight, int requestedDepth, int requestedRefreshRate)
>    {
>        // Try to find an exact match
>        DisplayMode displayMode = findDisplayModeInternal(displayModes, requestedWidth, requestedHeight, requestedDepth, requestedRefreshRate);
>        
>        // Try again, ignoring the requested bit depth
>        if (displayMode == null)
>            displayMode = findDisplayModeInternal(displayModes, requestedWidth, requestedHeight, DONT_CARE, DONT_CARE);
>        
>        // Try again, and again ignoring the requested bit depth and height
>        if (displayMode == null)
>            displayMode = findDisplayModeInternal(displayModes, requestedWidth, DONT_CARE, DONT_CARE, DONT_CARE);
>
>        // If all else fails try to get any display mode
>        if (displayMode == null)
>            displayMode = findDisplayModeInternal(displayModes, DONT_CARE, DONT_CARE, DONT_CARE, DONT_CARE);
>
>        return displayMode;
>    }
>    
>    private DisplayMode findDisplayModeInternal(DisplayMode[] displayModes, int requestedWidth, int requestedHeight, int requestedDepth, int requestedRefreshRate)
>    {
>        DisplayMode displayModeToUse = null;
>        for (int i = 0; i < displayModes.length; i++)
>        {
>            DisplayMode displayMode = displayModes[i];
>            if ((requestedWidth == DONT_CARE || displayMode.getWidth() == requestedWidth) &&
>            (requestedHeight == DONT_CARE || displayMode.getHeight() == requestedHeight) &&
>            (requestedHeight == DONT_CARE || displayMode.getRefreshRate() == requestedRefreshRate) &&
>            (requestedDepth == DONT_CARE || displayMode.getBitDepth() == requestedDepth))
>                displayModeToUse = displayMode;
>        }
>        
>        return displayModeToUse;
>    }
>    
>    public void addGLEventListener(GLEventListener glEventListener)
>    {
>        glCanvas.addGLEventListener(glEventListener);
>    }
>    
>    public void removeGLEventListener(GLEventListener glEventListener)
>    {
>        glCanvas.removeGLEventListener(glEventListener);
>    }
>    
>    public void addKeyListener(KeyListener l)
>    {
>        glCanvas.addKeyListener(l);
>    }
>    
>    public void addMouseListener(MouseListener l)
>    {
>        glCanvas.addMouseListener(l);
>    }
>    
>    public void addMouseMotionListener(MouseMotionListener l)
>    {
>        glCanvas.addMouseMotionListener(l);
>    }
>    
>    public void removeKeyListener(KeyListener l)
>    {
>        glCanvas.removeKeyListener(l);
>    }
>    
>    public void removeMouseListener(MouseListener l)
>    {
>        glCanvas.removeMouseListener(l);
>    }
>    
>    public void removeMouseMotionListener(MouseMotionListener l)
>    {
>        glCanvas.removeMouseMotionListener(l);
>    }
>    
>    private class MyShutdownKeyAdapter extends KeyAdapter
>    {
>        public void keyPressed(KeyEvent e)
>        {
>            if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
>            {
>                stop();
>            }
>        }
>    }
>    
>    private class MyShutdownWindowAdapter extends WindowAdapter
>    {
>        public void windowClosing(WindowEvent e)
>        {
>            stop();
>        }
>    }
>}

Actions: View

Attachments on bug 100: 25