JOGL Fullscreen Render - Java-Gaming.org

Hey maybe i have something selfmade for you!
Sorry for the german comments, i made this in my language.
Its a GLEventlistener subclass to use it directly with a JFrame and
to control it easily.
May it is something for you!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253

package soul2d.engine.graphic;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import soul2d.GameEngine;
import soul2d.engine.BGraphic;

import net.java.games.jogl.GL;
import net.java.games.jogl.GLCanvas;
import net.java.games.jogl.GLCapabilities;
import net.java.games.jogl.GLDrawable;
import net.java.games.jogl.GLDrawableFactory;
import net.java.games.jogl.GLU;

/**
 * Erstellt eine Jogl-Oberfläche innerhalb eines Fullscreens
 * 
 * @author Soulfly alias Ingo Müller
 */
public class FullscreenMode extends GLEventListener
{

   /**
    * Grafikkarte die benutzt wird
    */
   private GraphicsDevice      device;

   /**
    * JOGL Zeichenbereich
    */
   private volatile GLCanvas   glcanvas;

   /**
    * Höhe der Anzeigefläche
    */
   private int            height;

   /**
    * Engine Parent
    */
   private GameEngine                parent;

   /**
    * Breite der Anzeigefläche
    */
   private int                   width;

   /**
    * Konstruktor
    * 
    * @param WIDTH
    *            Breite
    * @param HEIGHT
    *            Höhe
    */
   public FullscreenMode(int WIDTH, int HEIGHT)
   {
      GraphicsEnvironment enviroment = GraphicsEnvironment.getLocalGraphicsEnvironment();
      device = enviroment.getDefaultScreenDevice();
      width = WIDTH;
      height = HEIGHT;
   }

   /*
    * (non-Javadoc)
    * 
    * @see net.java.games.jogl.GLEventListener#display(net.java.games.jogl.GLDrawable)
    */
   public void display(GLDrawable gld)
   {
      GL gl = gld.getGL();
      GLU glu = gld.getGLU();
      parent.display(gl, glu);
   }

   /*
    * (non-Javadoc)
    * 
    * @see net.java.games.jogl.GLEventListener#displayChanged(net.java.games.jogl.GLDrawable,
    *      boolean, boolean)
    */
   public void displayChanged(GLDrawable arg0, boolean arg1, boolean arg2)
   {
      parent.displayChanged(arg0, arg1, arg2);
   }

   /**
    * Gibt die momentanen Bildschirmeinstellungen zurück
    * 
    * @return Aktueller DisplayMode
    */
   public DisplayMode getCurrentDisplayMode()
   {
      return device.getDisplayMode();
   }

   /**
    * Gibt aktuellen Frame aus
    * 
    * @return Aktueller JFrame
    */
   public JFrame getFrame()
   {
      return (JFrame) device.getFullScreenWindow();
   }

   /**
    * Gibt die JOGL-Oberfläche zurück
    * 
    * @return Aktueller GLCanvas
    */
   public GLCanvas getGLCanvas()
   {
      return glcanvas;
   }

   /**
    * Gibt die Höhe zurück
    * 
    * @return Höhe
    */
   public int getHeight()
   {
      return glcanvas.getHeight();
   }

   /**
    * Gibt die Breite zurück
    * 
    * @return Breite
    */
   public int getWidth()
   {
      return glcanvas.getWidth();
   }

   /**
    * initialisiert die Anzeige
    * 
    * @param ge
    *            Aktuelle GameEngine
    */
   public void init(GameEngine ge)
   {
      parent = ge;
      setFullscreen();
   }

   /*
    * (non-Javadoc)
    * 
    * @see net.java.games.jogl.GLEventListener#init(net.java.games.jogl.GLDrawable)
    */
   public void init(GLDrawable gld)
   {
      GL gl = gld.getGL();
      GLU glu = gld.getGLU();
      gl.glClear(GL.GL_COLOR_BUFFER_BIT);

      gl.glViewport(0, 0, width, height);
      gl.glMatrixMode(GL.GL_PROJECTION);
      gl.glLoadIdentity();
      glu.gluOrtho2D(0.0, (double) width, 0.0, (double) height);
      
      //Aktiviert die Beachtung von Alphawerten
      gl.glEnable(GL.GL_ALPHA_TEST);
      gl.glAlphaFunc(GL.GL_GREATER, 0.0f);
      parent.init(gl, glu);
   }

   /**
    * Das Vollbild wird verlassen und der Bildschirm wird wieder hergestellt.
    */
   public void removeFullscreen()
   {
      Window fenster = getFrame();
      if (fenster != null)
         fenster.dispose();
      device.setFullScreenWindow(null);
   }

   /*
    * (non-Javadoc)
    * 
    * @see net.java.games.jogl.GLEventListener#reshape(net.java.games.jogl.GLDrawable,
    *      int, int, int, int)
    */
   public void reshape(GLDrawable arg0, int arg1, int arg2, int arg3, int arg4)
   {
      parent.reshape(arg0, arg1, arg2, arg3, arg4);
   }

   /**
    * Setzt die Bildschirmeinstellung
    * 
    * @param width
    *            Auflösungbreite
    * @param height
    *            Auflösungshöhe
    * @param color
    *            Farbtiefe
    * @param freq
    *            Bildschirmfrequenz
    */
   public void setDisplayMode(int width, int height, int color, int freq)
   {
      if (width != 0 && height != 0 && color != 0 && freq != 0 && device.isDisplayChangeSupported())
      {
         try
         {
            device.setDisplayMode(new DisplayMode(width, height, color, freq));
         }
         catch (IllegalArgumentException ex)
         {
         }

         getFrame().setSize(width, height);
      }
   }

   /**
    * Erstellt den Fullscreen
    */
   public void setFullscreen()
   {
      final JFrame frame = new JFrame();
      frame.setSize(width, height);
      frame.setUndecorated(true);
      frame.setIgnoreRepaint(true);
      frame.setResizable(false);

      frame.addWindowListener(new WindowAdapter()
      {
         public void windowClosing(WindowEvent e)
         {
            GameEngine.getFPSAnimator().stop();
            System.exit(0);
         }
      });

      glcanvas = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
      glcanvas.addGLEventListener(this);
      frame.add(glcanvas);

      // den JFrame als Vollbild setzen
      device.setFullScreenWindow(frame);
      setDisplayMode(width, height, 32, 60);
      glcanvas.requestFocusInWindow();

   }
}