merge render-refactoring branch into the HEAD

1 files changed, 330 insertions, 0 deletions

diff --git a/src/jake2/render/opengl/LwjglDriver.java b/src/jake2/render/opengl/LwjglDriver.java
new file mode 100644
index 0000000..04f30bf
--- /dev/null
+++ b/src/jake2/render/opengl/LwjglDriver.java
@@ -0,0 +1,330 @@
+/*
+ * LWJGLBase.java
+ * Copyright (C) 2004
+ * 
+ * $Id: LwjglDriver.java,v 1.2 2006-11-21 00:49:54 cawe Exp $
+ */
+/*
+ Copyright (C) 1997-2001 Id Software, Inc.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+ */
+package jake2.render.opengl;
+
+import jake2.Defines;
+import jake2.client.VID;
+import jake2.qcommon.Com;
+import jake2.qcommon.xcommand_t;
+import jake2.render.Base;
+
+import java.awt.Dimension;
+import java.util.LinkedList;
+
+import org.lwjgl.LWJGLException;
+import org.lwjgl.opengl.Display;
+import org.lwjgl.opengl.DisplayMode;
+
+/**
+ * LWJGLBase
+ * 
+ * @author dsanders/cwei
+ */
+public class LwjglDriver extends LwjglGL implements GLDriver {
+
+    protected LwjglDriver() {
+        // see LwjglRenderer
+    }
+
+    private DisplayMode oldDisplayMode;
+
+    // window position on the screen
+    int window_xpos, window_ypos;
+
+    private java.awt.DisplayMode toAwtDisplayMode(DisplayMode m) {
+        return new java.awt.DisplayMode(m.getWidth(), m.getHeight(), m
+                .getBitsPerPixel(), m.getFrequency());
+    }
+
+    public java.awt.DisplayMode[] getModeList() {
+	DisplayMode[] modes;
+	try {
+	    modes = Display.getAvailableDisplayModes();
+	} catch (LWJGLException e) {
+	    Com.Println(e.getMessage());
+	    return new java.awt.DisplayMode[0];
+	}
+        LinkedList l = new LinkedList();
+        l.add(toAwtDisplayMode(oldDisplayMode));
+
+        for (int i = 0; i < modes.length; i++) {
+            DisplayMode m = modes[i];
+
+            if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel())
+                continue;
+            if (m.getFrequency() > oldDisplayMode.getFrequency())
+                continue;
+            if (m.getHeight() < 240 || m.getWidth() < 320)
+                continue;
+
+            int j = 0;
+            java.awt.DisplayMode ml = null;
+            for (j = 0; j < l.size(); j++) {
+                ml = (java.awt.DisplayMode) l.get(j);
+                if (ml.getWidth() > m.getWidth())
+                    break;
+                if (ml.getWidth() == m.getWidth()
+                        && ml.getHeight() >= m.getHeight())
+                    break;
+            }
+            if (j == l.size()) {
+                l.addLast(toAwtDisplayMode(m));
+            } else if (ml.getWidth() > m.getWidth()
+                    || ml.getHeight() > m.getHeight()) {
+                l.add(j, toAwtDisplayMode(m));
+            } else if (m.getFrequency() > ml.getRefreshRate()) {
+                l.remove(j);
+                l.add(j, toAwtDisplayMode(m));
+            }
+        }
+        java.awt.DisplayMode[] ma = new java.awt.DisplayMode[l.size()];
+        l.toArray(ma);
+        return ma;
+    }
+
+    public DisplayMode[] getLWJGLModeList() {
+	DisplayMode[] modes;
+	try {
+	    modes = Display.getAvailableDisplayModes();
+	} catch (LWJGLException e) {
+	    Com.Println(e.getMessage());
+	    return new DisplayMode[0];
+	}
+
+        LinkedList l = new LinkedList();
+        l.add(oldDisplayMode);
+
+        for (int i = 0; i < modes.length; i++) {
+            DisplayMode m = modes[i];
+
+            if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel())
+                continue;
+            if (m.getFrequency() > oldDisplayMode.getFrequency())
+                continue;
+            if (m.getHeight() < 240 || m.getWidth() < 320)
+                continue;
+
+            int j = 0;
+            DisplayMode ml = null;
+            for (j = 0; j < l.size(); j++) {
+                ml = (DisplayMode) l.get(j);
+                if (ml.getWidth() > m.getWidth())
+                    break;
+                if (ml.getWidth() == m.getWidth()
+                        && ml.getHeight() >= m.getHeight())
+                    break;
+            }
+            if (j == l.size()) {
+                l.addLast(m);
+            } else if (ml.getWidth() > m.getWidth()
+                    || ml.getHeight() > m.getHeight()) {
+                l.add(j, m);
+            } else if (m.getFrequency() > ml.getFrequency()) {
+                l.remove(j);
+                l.add(j, m);
+            }
+        }
+        DisplayMode[] ma = new DisplayMode[l.size()];
+        l.toArray(ma);
+        return ma;
+    }
+
+    private DisplayMode findDisplayMode(Dimension dim) {
+        DisplayMode mode = null;
+        DisplayMode m = null;
+        DisplayMode[] modes = getLWJGLModeList();
+        int w = dim.width;
+        int h = dim.height;
+
+        for (int i = 0; i < modes.length; i++) {
+            m = modes[i];
+            if (m.getWidth() == w && m.getHeight() == h) {
+                mode = m;
+                break;
+            }
+        }
+        if (mode == null)
+            mode = oldDisplayMode;
+        return mode;
+    }
+
+    String getModeString(DisplayMode m) {
+        StringBuffer sb = new StringBuffer();
+        sb.append(m.getWidth());
+        sb.append('x');
+        sb.append(m.getHeight());
+        sb.append('x');
+        sb.append(m.getBitsPerPixel());
+        sb.append('@');
+        sb.append(m.getFrequency());
+        sb.append("Hz");
+        return sb.toString();
+    }
+
+    /**
+     * @param dim
+     * @param mode
+     * @param fullscreen
+     * @return enum rserr_t
+     */
+    public int setMode(Dimension dim, int mode, boolean fullscreen) {
+
+        Dimension newDim = new Dimension();
+
+        VID.Printf(Defines.PRINT_ALL, "Initializing OpenGL display\n");
+
+        VID.Printf(Defines.PRINT_ALL, "...setting mode " + mode + ":");
+
+        /*
+         * fullscreen handling
+         */
+        if (oldDisplayMode == null) {
+            oldDisplayMode = Display.getDisplayMode();
+        }
+
+        if (!VID.GetModeInfo(newDim, mode)) {
+            VID.Printf(Defines.PRINT_ALL, " invalid mode\n");
+            return Base.rserr_invalid_mode;
+        }
+
+        VID.Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height
+                + '\n');
+
+        // destroy the existing window
+        shutdown();
+
+        Display.setTitle("Jake2 (lwjgl)");
+        Display.setLocation(0, 0);
+
+        DisplayMode displayMode = findDisplayMode(newDim);
+        newDim.width = displayMode.getWidth();
+        newDim.height = displayMode.getHeight();
+
+        if (fullscreen) {
+            try {
+                Display.setDisplayMode(displayMode);
+            } catch (LWJGLException e) {
+                return Base.rserr_invalid_mode;
+            }
+
+            Display.setLocation(0, 0);
+
+            try {
+                Display.setFullscreen(fullscreen);
+            } catch (LWJGLException e) {
+                return Base.rserr_invalid_fullscreen;
+            }
+
+            VID.Printf(Defines.PRINT_ALL, "...setting fullscreen "
+                    + getModeString(displayMode) + '\n');
+
+        } else {
+            try {
+                Display.setDisplayMode(displayMode);
+            } catch (LWJGLException e) {
+                return Base.rserr_invalid_mode;
+            }
+
+            try {
+                Display.setFullscreen(false);
+            } catch (LWJGLException e) {
+                return Base.rserr_invalid_fullscreen;
+            }
+            Display.setLocation(window_xpos, window_ypos);
+        }
+
+        Base.setVid(newDim.width, newDim.height);
+
+        // vid.width = newDim.width;
+        // vid.height = newDim.height;
+
+        try {
+            Display.create();
+        } catch (LWJGLException e) {
+            return Base.rserr_unknown;
+        }
+
+        // let the sound and input subsystems know about the new window
+        VID.NewWindow(newDim.width, newDim.height);
+        return Base.rserr_ok;
+    }
+
+    public void shutdown() {
+        if (oldDisplayMode != null && Display.isFullscreen()) {
+            try {
+                Display.setDisplayMode(oldDisplayMode);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        while (Display.isCreated()) {
+            Display.destroy();
+        }
+    }
+
+    /**
+     * @return true
+     */
+    public boolean init(int xpos, int ypos) {
+        // do nothing
+        window_xpos = xpos;
+        window_ypos = ypos;
+        return true;
+    }
+
+    public void beginFrame(float camera_separation) {
+        // do nothing
+    }
+
+    public void endFrame() {
+        glFlush();
+        // swap buffers
+        Display.update();
+    }
+
+    public void appActivate(boolean activate) {
+        // do nothing
+    }
+
+    public void enableLogging(boolean enable) {
+        // do nothing
+    }
+
+    public void logNewFrame() {
+        // do nothing
+    }
+
+    /**
+     * this is a hack for jogl renderers.
+     * 
+     * @param callback
+     */
+    public final void updateScreen(xcommand_t callback) {
+        callback.execute();
+    }
+
+}