summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorcvs2svn <admin@example.com>2004-07-09 06:50:53 +0000
committercvs2svn <admin@example.com>2004-07-09 06:50:53 +0000
commit4ac2d590b2c18728ee636c391882619bc2a642b8 (patch)
tree5d3604bdc65c07eb40a2e08e4843f4823973bc7c
parent6b36f9e0380b7c80aecdc78ef07a0cf473712416 (diff)
parent20a66a892a3f0704ef37f1eebb681edfee6fc165 (diff)
This commit was manufactured by cvs2svn to create branch 'r_0_9'.
-rw-r--r--README_DE55
-rw-r--r--src/jake2/qcommon/CRC.java383
-rw-r--r--src/jake2/render/FastJoglRenderer.java306
-rw-r--r--src/jake2/render/fastjogl/Anorms.java219
-rw-r--r--src/jake2/render/fastjogl/Base.java300
-rw-r--r--src/jake2/render/fastjogl/Draw.java406
-rw-r--r--src/jake2/render/fastjogl/Image.java1673
-rw-r--r--src/jake2/render/fastjogl/Impl.java343
-rw-r--r--src/jake2/render/fastjogl/Light.java778
-rw-r--r--src/jake2/render/fastjogl/Main.java1592
-rw-r--r--src/jake2/render/fastjogl/Mesh.java753
-rw-r--r--src/jake2/render/fastjogl/Misc.java265
-rw-r--r--src/jake2/render/fastjogl/Model.java1347
-rw-r--r--src/jake2/render/fastjogl/Surf.java1464
-rw-r--r--src/jake2/render/fastjogl/Warp.java732
-rw-r--r--src/jake2/sound/WaveLoader.java302
-rw-r--r--src/jake2/sound/joal/Channel.java84
-rw-r--r--src/jake2/sound/joal/JOALSoundImpl.java793
18 files changed, 11795 insertions, 0 deletions
diff --git a/README_DE b/README_DE
new file mode 100644
index 0000000..7fd021e
--- /dev/null
+++ b/README_DE
@@ -0,0 +1,55 @@
+Jake2 README
+============
+
+Jake2 ist eine Java Portierung der Quake2 Engine von id Software. Id Software
+hat den Sourcecode der Quake2 Engine unter den Bedingungen der GPL
+veröffentlicht. Dementsprechend wird auch Jake2 unter der GPL (siehe LICENSE)
+lizensiert.
+
+Jake2 ist eine reine Java Anwendung. Als native Library kommen im Moment nur
+jogl für die OpenGL Anbindung und joal für OpenAudio Soundunterstützung zum
+Einsatz. Die komplette Funktionalität der Engine wurde ausschliesslich mit Java
+realisiert.
+
+Jake2 befindet sich noch im Entwicklungsstadium. Die Kontaktaddresse für
+Bugreports und Rückmeldungen ist jake2@bytonic.de.
+
+Jake2 wird von uns unter Linux und Windows2000/XP getestet. Wir haben Feedback,
+dass Jake2 richtigen plattformspezifischen jogl Bibliotheken auch auf Mac OS X
+läuft.
+
+Mindestanforderungen:
+400 MHz CPU
+Geforce2 MX oder bessere Grafikkarte
+JRE 1.4.2
+
+Installation
+------------
+
+ausgehend von der Binärdistribution:
+- jake2-version.tar.gz oder jake2-version.zip entpacken
+- baseq2 Verzeichnis des Quake2 Originals oder der Demoversion in das Jake2
+ Verzeichnis kopieren
+- mit Jake2.sh oder Jake2.bat starten
+
+ausgehend von Sourcedistribution:
+- jake2src-version.tar.gz oder jake2src-version.zip entpacken
+- JAVA_HOME Umgebungsvariable auf J2SDK1.4 Installationsverzeichnis setzen
+- "build.sh bindist" oder "build.bat bindist" erzeugt die Binärdistribution
+
+Quake2 Leveldaten installieren:
+- ftp://ftp.idsoftware.com/idstuff/quake2/q2-314-demo-x86.exe (37 MB)
+ herunterladen
+- Install\Data\baseq2\ aus q2-314-demo-x86.exe mit unzip oder Winzip
+ extrahieren
+- baseq2 ins Jake2 Verzeichnis kopieren
+
+viel Spass!
+
+bytonic Software
+
+Holger Zickner <hoz@bytonic.de>
+Carsten Weisse <cwei@bytonic.de>
+Rene Stoeckel <rst@bytonic.de>
+
+<jake2@bytonic.de> für Bugreports und Rückmeldungen. \ No newline at end of file
diff --git a/src/jake2/qcommon/CRC.java b/src/jake2/qcommon/CRC.java
new file mode 100644
index 0000000..ca22d9b
--- /dev/null
+++ b/src/jake2/qcommon/CRC.java
@@ -0,0 +1,383 @@
+/*
+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.
+
+*/
+
+// Created on 25.01.2004 by RST.
+// $Id: CRC.java,v 1.1 2004-07-09 06:50:49 hzi Exp $
+package jake2.qcommon;
+
+import jake2.util.Vargs;
+
+public class CRC
+{
+
+ public final static short CRC_INIT_VALUE= (short) 0xffff;
+ public final static short CRC_XOR_VALUE= (short) 0x0000;
+
+ private static int crctable[]=
+ {
+ 0x0000,
+ 0x1021,
+ 0x2042,
+ 0x3063,
+ 0x4084,
+ 0x50a5,
+ 0x60c6,
+ 0x70e7,
+ 0x8108,
+ 0x9129,
+ 0xa14a,
+ 0xb16b,
+ 0xc18c,
+ 0xd1ad,
+ 0xe1ce,
+ 0xf1ef,
+ 0x1231,
+ 0x0210,
+ 0x3273,
+ 0x2252,
+ 0x52b5,
+ 0x4294,
+ 0x72f7,
+ 0x62d6,
+ 0x9339,
+ 0x8318,
+ 0xb37b,
+ 0xa35a,
+ 0xd3bd,
+ 0xc39c,
+ 0xf3ff,
+ 0xe3de,
+ 0x2462,
+ 0x3443,
+ 0x0420,
+ 0x1401,
+ 0x64e6,
+ 0x74c7,
+ 0x44a4,
+ 0x5485,
+ 0xa56a,
+ 0xb54b,
+ 0x8528,
+ 0x9509,
+ 0xe5ee,
+ 0xf5cf,
+ 0xc5ac,
+ 0xd58d,
+ 0x3653,
+ 0x2672,
+ 0x1611,
+ 0x0630,
+ 0x76d7,
+ 0x66f6,
+ 0x5695,
+ 0x46b4,
+ 0xb75b,
+ 0xa77a,
+ 0x9719,
+ 0x8738,
+ 0xf7df,
+ 0xe7fe,
+ 0xd79d,
+ 0xc7bc,
+ 0x48c4,
+ 0x58e5,
+ 0x6886,
+ 0x78a7,
+ 0x0840,
+ 0x1861,
+ 0x2802,
+ 0x3823,
+ 0xc9cc,
+ 0xd9ed,
+ 0xe98e,
+ 0xf9af,
+ 0x8948,
+ 0x9969,
+ 0xa90a,
+ 0xb92b,
+ 0x5af5,
+ 0x4ad4,
+ 0x7ab7,
+ 0x6a96,
+ 0x1a71,
+ 0x0a50,
+ 0x3a33,
+ 0x2a12,
+ 0xdbfd,
+ 0xcbdc,
+ 0xfbbf,
+ 0xeb9e,
+ 0x9b79,
+ 0x8b58,
+ 0xbb3b,
+ 0xab1a,
+ 0x6ca6,
+ 0x7c87,
+ 0x4ce4,
+ 0x5cc5,
+ 0x2c22,
+ 0x3c03,
+ 0x0c60,
+ 0x1c41,
+ 0xedae,
+ 0xfd8f,
+ 0xcdec,
+ 0xddcd,
+ 0xad2a,
+ 0xbd0b,
+ 0x8d68,
+ 0x9d49,
+ 0x7e97,
+ 0x6eb6,
+ 0x5ed5,
+ 0x4ef4,
+ 0x3e13,
+ 0x2e32,
+ 0x1e51,
+ 0x0e70,
+ 0xff9f,
+ 0xefbe,
+ 0xdfdd,
+ 0xcffc,
+ 0xbf1b,
+ 0xaf3a,
+ 0x9f59,
+ 0x8f78,
+ 0x9188,
+ 0x81a9,
+ 0xb1ca,
+ 0xa1eb,
+ 0xd10c,
+ 0xc12d,
+ 0xf14e,
+ 0xe16f,
+ 0x1080,
+ 0x00a1,
+ 0x30c2,
+ 0x20e3,
+ 0x5004,
+ 0x4025,
+ 0x7046,
+ 0x6067,
+ 0x83b9,
+ 0x9398,
+ 0xa3fb,
+ 0xb3da,
+ 0xc33d,
+ 0xd31c,
+ 0xe37f,
+ 0xf35e,
+ 0x02b1,
+ 0x1290,
+ 0x22f3,
+ 0x32d2,
+ 0x4235,
+ 0x5214,
+ 0x6277,
+ 0x7256,
+ 0xb5ea,
+ 0xa5cb,
+ 0x95a8,
+ 0x8589,
+ 0xf56e,
+ 0xe54f,
+ 0xd52c,
+ 0xc50d,
+ 0x34e2,
+ 0x24c3,
+ 0x14a0,
+ 0x0481,
+ 0x7466,
+ 0x6447,
+ 0x5424,
+ 0x4405,
+ 0xa7db,
+ 0xb7fa,
+ 0x8799,
+ 0x97b8,
+ 0xe75f,
+ 0xf77e,
+ 0xc71d,
+ 0xd73c,
+ 0x26d3,
+ 0x36f2,
+ 0x0691,
+ 0x16b0,
+ 0x6657,
+ 0x7676,
+ 0x4615,
+ 0x5634,
+ 0xd94c,
+ 0xc96d,
+ 0xf90e,
+ 0xe92f,
+ 0x99c8,
+ 0x89e9,
+ 0xb98a,
+ 0xa9ab,
+ 0x5844,
+ 0x4865,
+ 0x7806,
+ 0x6827,
+ 0x18c0,
+ 0x08e1,
+ 0x3882,
+ 0x28a3,
+ 0xcb7d,
+ 0xdb5c,
+ 0xeb3f,
+ 0xfb1e,
+ 0x8bf9,
+ 0x9bd8,
+ 0xabbb,
+ 0xbb9a,
+ 0x4a75,
+ 0x5a54,
+ 0x6a37,
+ 0x7a16,
+ 0x0af1,
+ 0x1ad0,
+ 0x2ab3,
+ 0x3a92,
+ 0xfd2e,
+ 0xed0f,
+ 0xdd6c,
+ 0xcd4d,
+ 0xbdaa,
+ 0xad8b,
+ 0x9de8,
+ 0x8dc9,
+ 0x7c26,
+ 0x6c07,
+ 0x5c64,
+ 0x4c45,
+ 0x3ca2,
+ 0x2c83,
+ 0x1ce0,
+ 0x0cc1,
+ 0xef1f,
+ 0xff3e,
+ 0xcf5d,
+ 0xdf7c,
+ 0xaf9b,
+ 0xbfba,
+ 0x8fd9,
+ 0x9ff8,
+ 0x6e17,
+ 0x7e36,
+ 0x4e55,
+ 0x5e74,
+ 0x2e93,
+ 0x3eb2,
+ 0x0ed1,
+ 0x1ef0 };
+
+ static short CRC_Block(byte start[], int count)
+ {
+ short crc= CRC_INIT_VALUE;
+
+ int ndx= 0;
+
+ while (count-- > 0)
+ crc= (short) ((crc << 8) ^ crctable[0xff & ((crc >> 8) ^ start[ndx++])]);
+
+ return crc;
+ }
+
+ public static void main(String[] args)
+ {
+ byte data[]=
+ {
+ (byte) 0x71,
+ (byte) 0xa9,
+ (byte) 0x05,
+ (byte) 0xce,
+ (byte) 0x8d,
+ (byte) 0x75,
+ (byte) 0x28,
+ (byte) 0xc8,
+ (byte) 0xba,
+ (byte) 0x97,
+
+ (byte) 0x45,
+ (byte) 0xe9,
+ (byte) 0x8a,
+ (byte) 0xe0,
+ (byte) 0x37,
+ (byte) 0xbd,
+ (byte) 0x6c,
+ (byte) 0x6d,
+ (byte) 0x67,
+ (byte) 0x4a,
+ (byte) 0x21 };
+ System.out.println("crc:" + (CRC_Block(data, 21) & 0xffff));
+ System.out.println("----");
+ for (int n=0; n < 5; n++)
+ System.out.println("seq:" + (Com.BlockSequenceCRCByte( data,0, 21,n*10) & 0xff));
+
+ }
+
+/* c test:
+ *
+ * D:\Rene\gamesrc\quake2-3.21\qcommon>crc
+ * crc=-12353
+ * ----
+ * seq:215
+ * seq:252
+ * seq:164
+ * seq:202
+ * seq:201
+ *
+int main()
+{
+ byte data[21] =
+ {
+ 0x71,
+ 0xa9,
+ 0x05,
+ 0xce,
+ 0x8d,
+ 0x75,
+ 0x28,
+ 0xc8,
+ 0xba,
+ 0x97,
+
+ 0x45,
+ 0xe9,
+ 0x8a,
+ 0xe0,
+ 0x37,
+ 0xbd,
+ 0x6c,
+ 0x6d,
+ 0x67,
+ 0x4a, 0x21 };
+ int n=0;
+
+ printf("crc=%d\n", (short) CRC_Block(&data, 21));
+
+ printf("----\n");
+ for (n=0; n < 5; n++)
+ printf("seq:%d\n", COM_BlockSequenceCRCByte( &data,21, n*10) );
+}
+ */
+
+}
diff --git a/src/jake2/render/FastJoglRenderer.java b/src/jake2/render/FastJoglRenderer.java
new file mode 100644
index 0000000..da20bfd
--- /dev/null
+++ b/src/jake2/render/FastJoglRenderer.java
@@ -0,0 +1,306 @@
+/*
+ * FastJoglRenderer.java
+ * Copyright (C) 2003
+ *
+ * $Id: FastJoglRenderer.java,v 1.1 2004-07-09 06:50:47 hzi 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;
+
+import jake2.Defines;
+import jake2.client.*;
+import jake2.qcommon.xcommand_t;
+import jake2.render.fastjogl.Impl;
+
+import java.awt.Dimension;
+
+/**
+ * FastJoglRenderer
+ *
+ * @author cwei
+ */
+final class FastJoglRenderer extends Impl implements refexport_t, Ref {
+
+ static {
+ Renderer.register(new FastJoglRenderer());
+ };
+
+ private FastJoglRenderer() {
+ }
+
+ // ============================================================================
+ // public interface for Renderer implementations
+ //
+ // refexport_t (ref.h)
+ // ============================================================================
+
+ /**
+ * @see jake2.client.refexport_t#Init()
+ */
+ public boolean Init(int vid_xpos, int vid_ypos) {
+
+ // pre init
+ if (!R_Init(vid_xpos, vid_ypos)) return false;
+ // calls the R_Init2() internally
+ updateScreen();
+ // the result from R_Init2()
+ return post_init;
+ }
+
+ /**
+ * @see jake2.client.refexport_t#Shutdown()
+ */
+ public void Shutdown() {
+ R_Shutdown();
+ }
+
+ /**
+ * @see jake2.client.refexport_t#BeginRegistration(java.lang.String)
+ */
+ public void BeginRegistration(String map) {
+ if (contextInUse) {
+ R_BeginRegistration(map);
+ return;
+ }
+ this.name = map;
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ R_BeginRegistration(FastJoglRenderer.this.name);
+ }
+ });
+ }
+
+
+ private model_t model = null;
+ private String name = null;
+
+ /**
+ * @see jake2.client.refexport_t#RegisterModel(java.lang.String)
+ */
+ public model_t RegisterModel(String name) {
+
+ if (contextInUse)
+ return R_RegisterModel(name);
+
+ model = null;
+ this.name = name;
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ FastJoglRenderer.this.model = R_RegisterModel(FastJoglRenderer.this.name);
+ }
+ });
+ return model;
+ }
+
+ /**
+ * @see jake2.client.refexport_t#RegisterSkin(java.lang.String)
+ */
+ public image_t RegisterSkin(String name) {
+ if (contextInUse)
+ return R_RegisterSkin(name);
+
+ this.image = null;
+ this.name = name;
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ FastJoglRenderer.this.image = R_RegisterSkin(FastJoglRenderer.this.name);
+ }
+ });
+ return image;
+ }
+
+ private image_t image = null;
+
+ /**
+ * @see jake2.client.refexport_t#RegisterPic(java.lang.String)
+ */
+ public image_t RegisterPic(String name) {
+ if (contextInUse)
+ return Draw_FindPic(name);
+
+ this.image = null;
+ this.name = name;
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ FastJoglRenderer.this.image = Draw_FindPic(FastJoglRenderer.this.name);
+ }
+ });
+ return image;
+ }
+
+
+ private float[] axis;
+ private float rotate;
+
+ /**
+ * @see jake2.client.refexport_t#SetSky(java.lang.String, float, float[])
+ */
+ public void SetSky(String name, float rotate, float[] axis) {
+ if (contextInUse) {
+ R_SetSky(name, rotate, axis);
+ return;
+ }
+
+ this.name = name;
+ this.rotate = rotate;
+ this.axis = axis;
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ R_SetSky(FastJoglRenderer.this.name, FastJoglRenderer.this.rotate, FastJoglRenderer.this.axis);
+ }
+ });
+
+ }
+
+ /**
+ * @see jake2.client.refexport_t#EndRegistration()
+ */
+ public void EndRegistration() {
+ if (contextInUse) {
+ R_EndRegistration();
+ return;
+ }
+
+ updateScreen(new xcommand_t() {
+ public void execute() {
+ R_EndRegistration();
+ }
+ });
+ }
+
+ /**
+ * @see jake2.client.refexport_t#RenderFrame(jake2.client.refdef_t)
+ */
+ public void RenderFrame(refdef_t fd) {
+ R_RenderFrame(fd);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawGetPicSize(java.awt.Dimension, java.lang.String)
+ */
+ public void DrawGetPicSize(Dimension dim, String name) {
+ Draw_GetPicSize(dim, name);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawPic(int, int, java.lang.String)
+ */
+ public void DrawPic(int x, int y, String name) {
+ Draw_Pic(x, y, name);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawStretchPic(int, int, int, int, java.lang.String)
+ */
+ public void DrawStretchPic(int x, int y, int w, int h, String name) {
+ Draw_StretchPic(x, y, w, h, name);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawChar(int, int, int)
+ */
+ public void DrawChar(int x, int y, int num) {
+ Draw_Char(x, y, num);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawTileClear(int, int, int, int, java.lang.String)
+ */
+ public void DrawTileClear(int x, int y, int w, int h, String name) {
+ Draw_TileClear(x, y, w, h, name);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawFill(int, int, int, int, int)
+ */
+ public void DrawFill(int x, int y, int w, int h, int c) {
+ Draw_Fill(x, y, w, h, c);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawFadeScreen()
+ */
+ public void DrawFadeScreen() {
+ Draw_FadeScreen();
+ }
+
+ /**
+ * @see jake2.client.refexport_t#DrawStretchRaw(int, int, int, int, int, int, byte[])
+ */
+ public void DrawStretchRaw(int x, int y, int w, int h, int cols, int rows, byte[] data) {
+ Draw_StretchRaw(x, y, w, h, cols, rows, data);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#CinematicSetPalette(byte[])
+ */
+ public void CinematicSetPalette(byte[] palette) {
+ R_SetPalette(palette);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#BeginFrame(float)
+ */
+ public void BeginFrame(float camera_separation) {
+ R_BeginFrame(camera_separation);
+ }
+
+ /**
+ * @see jake2.client.refexport_t#EndFrame()
+ */
+ public void EndFrame() {
+ GLimp_EndFrame();
+ }
+
+ /**
+ * @see jake2.client.refexport_t#AppActivate(boolean)
+ */
+ public void AppActivate(boolean activate) {
+ GLimp_AppActivate(activate);
+ }
+
+ public int apiVersion() {
+ return Defines.API_VERSION;
+ }
+
+ // ============================================================================
+ // Ref interface
+ // ============================================================================
+
+ public String getName() {
+ return DRIVER_NAME;
+ }
+
+ public String toString() {
+ return DRIVER_NAME;
+ }
+
+ public refexport_t GetRefAPI(refimport_t rimp) {
+ this.ri = rimp;
+ return this;
+ }
+
+} \ No newline at end of file
diff --git a/src/jake2/render/fastjogl/Anorms.java b/src/jake2/render/fastjogl/Anorms.java
new file mode 100644
index 0000000..552b305
--- /dev/null
+++ b/src/jake2/render/fastjogl/Anorms.java
@@ -0,0 +1,219 @@
+/*
+ * Anorms.java
+ * Copyright (C) 2003
+ *
+ * $Id: Anorms.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+/**
+ * Anorms
+ *
+ * @author cwei
+ */
+public interface Anorms {
+
+ final float[][] VERTEXNORMALS = {
+ {-0.525731f, 0.000000f, 0.850651f},
+ {-0.442863f, 0.238856f, 0.864188f},
+ {-0.295242f, 0.000000f, 0.955423f},
+ {-0.309017f, 0.500000f, 0.809017f},
+ {-0.162460f, 0.262866f, 0.951056f},
+ {0.000000f, 0.000000f, 1.000000f},
+ {0.000000f, 0.850651f, 0.525731f},
+ {-0.147621f, 0.716567f, 0.681718f},
+ {0.147621f, 0.716567f, 0.681718f},
+ {0.000000f, 0.525731f, 0.850651f},
+ {0.309017f, 0.500000f, 0.809017f},
+ {0.525731f, 0.000000f, 0.850651f},
+ {0.295242f, 0.000000f, 0.955423f},
+ {0.442863f, 0.238856f, 0.864188f},
+ {0.162460f, 0.262866f, 0.951056f},
+ {-0.681718f, 0.147621f, 0.716567f},
+ {-0.809017f, 0.309017f, 0.500000f},
+ {-0.587785f, 0.425325f, 0.688191f},
+ {-0.850651f, 0.525731f, 0.000000f},
+ {-0.864188f, 0.442863f, 0.238856f},
+ {-0.716567f, 0.681718f, 0.147621f},
+ {-0.688191f, 0.587785f, 0.425325f},
+ {-0.500000f, 0.809017f, 0.309017f},
+ {-0.238856f, 0.864188f, 0.442863f},
+ {-0.425325f, 0.688191f, 0.587785f},
+ {-0.716567f, 0.681718f, -0.147621f},
+ {-0.500000f, 0.809017f, -0.309017f},
+ {-0.525731f, 0.850651f, 0.000000f},
+ {0.000000f, 0.850651f, -0.525731f},
+ {-0.238856f, 0.864188f, -0.442863f},
+ {0.000000f, 0.955423f, -0.295242f},
+ {-0.262866f, 0.951056f, -0.162460f},
+ {0.000000f, 1.000000f, 0.000000f},
+ {0.000000f, 0.955423f, 0.295242f},
+ {-0.262866f, 0.951056f, 0.162460f},
+ {0.238856f, 0.864188f, 0.442863f},
+ {0.262866f, 0.951056f, 0.162460f},
+ {0.500000f, 0.809017f, 0.309017f},
+ {0.238856f, 0.864188f, -0.442863f},
+ {0.262866f, 0.951056f, -0.162460f},
+ {0.500000f, 0.809017f, -0.309017f},
+ {0.850651f, 0.525731f, 0.000000f},
+ {0.716567f, 0.681718f, 0.147621f},
+ {0.716567f, 0.681718f, -0.147621f},
+ {0.525731f, 0.850651f, 0.000000f},
+ {0.425325f, 0.688191f, 0.587785f},
+ {0.864188f, 0.442863f, 0.238856f},
+ {0.688191f, 0.587785f, 0.425325f},
+ {0.809017f, 0.309017f, 0.500000f},
+ {0.681718f, 0.147621f, 0.716567f},
+ {0.587785f, 0.425325f, 0.688191f},
+ {0.955423f, 0.295242f, 0.000000f},
+ {1.000000f, 0.000000f, 0.000000f},
+ {0.951056f, 0.162460f, 0.262866f},
+ {0.850651f, -0.525731f, 0.000000f},
+ {0.955423f, -0.295242f, 0.000000f},
+ {0.864188f, -0.442863f, 0.238856f},
+ {0.951056f, -0.162460f, 0.262866f},
+ {0.809017f, -0.309017f, 0.500000f},
+ {0.681718f, -0.147621f, 0.716567f},
+ {0.850651f, 0.000000f, 0.525731f},
+ {0.864188f, 0.442863f, -0.238856f},
+ {0.809017f, 0.309017f, -0.500000f},
+ {0.951056f, 0.162460f, -0.262866f},
+ {0.525731f, 0.000000f, -0.850651f},
+ {0.681718f, 0.147621f, -0.716567f},
+ {0.681718f, -0.147621f, -0.716567f},
+ {0.850651f, 0.000000f, -0.525731f},
+ {0.809017f, -0.309017f, -0.500000f},
+ {0.864188f, -0.442863f, -0.238856f},
+ {0.951056f, -0.162460f, -0.262866f},
+ {0.147621f, 0.716567f, -0.681718f},
+ {0.309017f, 0.500000f, -0.809017f},
+ {0.425325f, 0.688191f, -0.587785f},
+ {0.442863f, 0.238856f, -0.864188f},
+ {0.587785f, 0.425325f, -0.688191f},
+ {0.688191f, 0.587785f, -0.425325f},
+ {-0.147621f, 0.716567f, -0.681718f},
+ {-0.309017f, 0.500000f, -0.809017f},
+ {0.000000f, 0.525731f, -0.850651f},
+ {-0.525731f, 0.000000f, -0.850651f},
+ {-0.442863f, 0.238856f, -0.864188f},
+ {-0.295242f, 0.000000f, -0.955423f},
+ {-0.162460f, 0.262866f, -0.951056f},
+ {0.000000f, 0.000000f, -1.000000f},
+ {0.295242f, 0.000000f, -0.955423f},
+ {0.162460f, 0.262866f, -0.951056f},
+ {-0.442863f, -0.238856f, -0.864188f},
+ {-0.309017f, -0.500000f, -0.809017f},
+ {-0.162460f, -0.262866f, -0.951056f},
+ {0.000000f, -0.850651f, -0.525731f},
+ {-0.147621f, -0.716567f, -0.681718f},
+ {0.147621f, -0.716567f, -0.681718f},
+ {0.000000f, -0.525731f, -0.850651f},
+ {0.309017f, -0.500000f, -0.809017f},
+ {0.442863f, -0.238856f, -0.864188f},
+ {0.162460f, -0.262866f, -0.951056f},
+ {0.238856f, -0.864188f, -0.442863f},
+ {0.500000f, -0.809017f, -0.309017f},
+ {0.425325f, -0.688191f, -0.587785f},
+ {0.716567f, -0.681718f, -0.147621f},
+ {0.688191f, -0.587785f, -0.425325f},
+ {0.587785f, -0.425325f, -0.688191f},
+ {0.000000f, -0.955423f, -0.295242f},
+ {0.000000f, -1.000000f, 0.000000f},
+ {0.262866f, -0.951056f, -0.162460f},
+ {0.000000f, -0.850651f, 0.525731f},
+ {0.000000f, -0.955423f, 0.295242f},
+ {0.238856f, -0.864188f, 0.442863f},
+ {0.262866f, -0.951056f, 0.162460f},
+ {0.500000f, -0.809017f, 0.309017f},
+ {0.716567f, -0.681718f, 0.147621f},
+ {0.525731f, -0.850651f, 0.000000f},
+ {-0.238856f, -0.864188f, -0.442863f},
+ {-0.500000f, -0.809017f, -0.309017f},
+ {-0.262866f, -0.951056f, -0.162460f},
+ {-0.850651f, -0.525731f, 0.000000f},
+ {-0.716567f, -0.681718f, -0.147621f},
+ {-0.716567f, -0.681718f, 0.147621f},
+ {-0.525731f, -0.850651f, 0.000000f},
+ {-0.500000f, -0.809017f, 0.309017f},
+ {-0.238856f, -0.864188f, 0.442863f},
+ {-0.262866f, -0.951056f, 0.162460f},
+ {-0.864188f, -0.442863f, 0.238856f},
+ {-0.809017f, -0.309017f, 0.500000f},
+ {-0.688191f, -0.587785f, 0.425325f},
+ {-0.681718f, -0.147621f, 0.716567f},
+ {-0.442863f, -0.238856f, 0.864188f},
+ {-0.587785f, -0.425325f, 0.688191f},
+ {-0.309017f, -0.500000f, 0.809017f},
+ {-0.147621f, -0.716567f, 0.681718f},
+ {-0.425325f, -0.688191f, 0.587785f},
+ {-0.162460f, -0.262866f, 0.951056f},
+ {0.442863f, -0.238856f, 0.864188f},
+ {0.162460f, -0.262866f, 0.951056f},
+ {0.309017f, -0.500000f, 0.809017f},
+ {0.147621f, -0.716567f, 0.681718f},
+ {0.000000f, -0.525731f, 0.850651f},
+ {0.425325f, -0.688191f, 0.587785f},
+ {0.587785f, -0.425325f, 0.688191f},
+ {0.688191f, -0.587785f, 0.425325f},
+ {-0.955423f, 0.295242f, 0.000000f},
+ {-0.951056f, 0.162460f, 0.262866f},
+ {-1.000000f, 0.000000f, 0.000000f},
+ {-0.850651f, 0.000000f, 0.525731f},
+ {-0.955423f, -0.295242f, 0.000000f},
+ {-0.951056f, -0.162460f, 0.262866f},
+ {-0.864188f, 0.442863f, -0.238856f},
+ {-0.951056f, 0.162460f, -0.262866f},
+ {-0.809017f, 0.309017f, -0.500000f},
+ {-0.864188f, -0.442863f, -0.238856f},
+ {-0.951056f, -0.162460f, -0.262866f},
+ {-0.809017f, -0.309017f, -0.500000f},
+ {-0.681718f, 0.147621f, -0.716567f},
+ {-0.681718f, -0.147621f, -0.716567f},
+ {-0.850651f, 0.000000f, -0.525731f},
+ {-0.688191f, 0.587785f, -0.425325f},
+ {-0.587785f, 0.425325f, -0.688191f},
+ {-0.425325f, 0.688191f, -0.587785f},
+ {-0.425325f, -0.688191f, -0.587785f},
+ {-0.587785f, -0.425325f, -0.688191f},
+ {-0.688191f, -0.587785f, -0.425325f}
+ };
+
+ final float[][] VERTEXNORMAL_DOTS = {
+ {1.23f,1.30f,1.47f,1.35f,1.56f,1.71f,1.37f,1.38f,1.59f,1.60f,1.79f,1.97f,1.88f,1.92f,1.79f,1.02f,0.93f,1.07f,0.82f,0.87f,0.88f,0.94f,0.96f,1.14f,1.11f,0.82f,0.83f,0.89f,0.89f,0.86f,0.94f,0.91f,1.00f,1.21f,0.98f,1.48f,1.30f,1.57f,0.96f,1.07f,1.14f,1.60f,1.61f,1.40f,1.37f,1.72f,1.78f,1.79f,1.93f,1.99f,1.90f,1.68f,1.71f,1.86f,1.60f,1.68f,1.78f,1.86f,1.93f,1.99f,1.97f,1.44f,1.22f,1.49f,0.93f,0.99f,0.99f,1.23f,1.22f,1.44f,1.49f,0.89f,0.89f,0.97f,0.91f,0.98f,1.19f,0.82f,0.76f,0.82f,0.71f,0.72f,0.73f,0.76f,0.79f,0.86f,0.83f,0.72f,0.76f,0.76f,0.89f,0.82f,0.89f,0.82f,0.89f,0.91f,0.83f,0.96f,1.14f,0.97f,1.40f,1.19f,0.98f,0.94f,1.00f,1.07f,1.37f,1.21f,1.48f,1.30f,1.57f,1.61f,1.37f,0.86f,0.83f,0.91f,0.82f,0.82f,0.88f,0.89f,0.96f,1.14f,0.98f,0.87f,0.93f,0.94f,1.02f,1.30f,1.07f,1.35f,1.38f,1.11f,1.56f,1.92f,1.79f,1.79f,1.59f,1.60f,1.72f,1.90f,1.79f,0.80f,0.85f,0.79f,0.93f,0.80f,0.85f,0.77f,0.74f,0.72f,0.77f,0.74f,0.72f,0.70f,0.70f,0.71f,0.76f,0.73f,0.79f,0.79f,0.73f,0.76f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.26f,1.26f,1.48f,1.23f,1.50f,1.71f,1.14f,1.19f,1.38f,1.46f,1.64f,1.94f,1.87f,1.84f,1.71f,1.02f,0.92f,1.00f,0.79f,0.85f,0.84f,0.91f,0.90f,0.98f,0.99f,0.77f,0.77f,0.83f,0.82f,0.79f,0.86f,0.84f,0.92f,0.99f,0.91f,1.24f,1.03f,1.33f,0.88f,0.94f,0.97f,1.41f,1.39f,1.18f,1.11f,1.51f,1.61f,1.59f,1.80f,1.91f,1.76f,1.54f,1.65f,1.76f,1.70f,1.70f,1.85f,1.85f,1.97f,1.99f,1.93f,1.28f,1.09f,1.39f,0.92f,0.97f,0.99f,1.18f,1.26f,1.52f,1.48f,0.83f,0.85f,0.90f,0.88f,0.93f,1.00f,0.77f,0.73f,0.78f,0.72f,0.71f,0.74f,0.75f,0.79f,0.86f,0.81f,0.75f,0.81f,0.79f,0.96f,0.88f,0.94f,0.86f,0.93f,0.92f,0.85f,1.08f,1.33f,1.05f,1.55f,1.31f,1.01f,1.05f,1.27f,1.31f,1.60f,1.47f,1.70f,1.54f,1.76f,1.76f,1.57f,0.93f,0.90f,0.99f,0.88f,0.88f,0.95f,0.97f,1.11f,1.39f,1.20f,0.92f,0.97f,1.01f,1.10f,1.39f,1.22f,1.51f,1.58f,1.32f,1.64f,1.97f,1.85f,1.91f,1.77f,1.74f,1.88f,1.99f,1.91f,0.79f,0.86f,0.80f,0.94f,0.84f,0.88f,0.74f,0.74f,0.71f,0.82f,0.77f,0.76f,0.70f,0.73f,0.72f,0.73f,0.70f,0.74f,0.85f,0.77f,0.82f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.34f,1.27f,1.53f,1.17f,1.46f,1.71f,0.98f,1.05f,1.20f,1.34f,1.48f,1.86f,1.82f,1.71f,1.62f,1.09f,0.94f,0.99f,0.79f,0.85f,0.82f,0.90f,0.87f,0.93f,0.96f,0.76f,0.74f,0.79f,0.76f,0.74f,0.79f,0.78f,0.85f,0.92f,0.85f,1.00f,0.93f,1.06f,0.81f,0.86f,0.89f,1.16f,1.12f,0.97f,0.95f,1.28f,1.38f,1.35f,1.60f,1.77f,1.57f,1.33f,1.50f,1.58f,1.69f,1.63f,1.82f,1.74f,1.91f,1.92f,1.80f,1.04f,0.97f,1.21f,0.90f,0.93f,0.97f,1.05f,1.21f,1.48f,1.37f,0.77f,0.80f,0.84f,0.85f,0.88f,0.92f,0.73f,0.71f,0.74f,0.74f,0.71f,0.75f,0.73f,0.79f,0.84f,0.78f,0.79f,0.86f,0.81f,1.05f,0.94f,0.99f,0.90f,0.95f,0.92f,0.86f,1.24f,1.44f,1.14f,1.59f,1.34f,1.02f,1.27f,1.50f,1.49f,1.80f,1.69f,1.86f,1.72f,1.87f,1.80f,1.69f,1.00f,0.98f,1.23f,0.95f,0.96f,1.09f,1.16f,1.37f,1.63f,1.46f,0.99f,1.10f,1.25f,1.24f,1.51f,1.41f,1.67f,1.77f,1.55f,1.72f,1.95f,1.89f,1.98f,1.91f,1.86f,1.97f,1.99f,1.94f,0.81f,0.89f,0.85f,0.98f,0.90f,0.94f,0.75f,0.78f,0.73f,0.89f,0.83f,0.82f,0.72f,0.77f,0.76f,0.72f,0.70f,0.71f,0.91f,0.83f,0.89f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.46f,1.34f,1.60f,1.16f,1.46f,1.71f,0.94f,0.99f,1.05f,1.26f,1.33f,1.74f,1.76f,1.57f,1.54f,1.23f,0.98f,1.05f,0.83f,0.89f,0.84f,0.92f,0.87f,0.91f,0.96f,0.78f,0.74f,0.79f,0.72f,0.72f,0.75f,0.76f,0.80f,0.88f,0.83f,0.94f,0.87f,0.95f,0.76f,0.80f,0.82f,0.97f,0.96f,0.89f,0.88f,1.08f,1.11f,1.10f,1.37f,1.59f,1.37f,1.07f,1.27f,1.34f,1.57f,1.45f,1.69f,1.55f,1.77f,1.79f,1.60f,0.93f,0.90f,0.99f,0.86f,0.87f,0.93f,0.96f,1.07f,1.35f,1.18f,0.73f,0.76f,0.77f,0.81f,0.82f,0.85f,0.70f,0.71f,0.72f,0.78f,0.73f,0.77f,0.73f,0.79f,0.82f,0.76f,0.83f,0.90f,0.84f,1.18f,0.98f,1.03f,0.92f,0.95f,0.90f,0.86f,1.32f,1.45f,1.15f,1.53f,1.27f,0.99f,1.42f,1.65f,1.58f,1.93f,1.83f,1.94f,1.81f,1.88f,1.74f,1.70f,1.19f,1.17f,1.44f,1.11f,1.15f,1.36f,1.41f,1.61f,1.81f,1.67f,1.22f,1.34f,1.50f,1.42f,1.65f,1.61f,1.82f,1.91f,1.75f,1.80f,1.89f,1.89f,1.98f,1.99f,1.94f,1.98f,1.92f,1.87f,0.86f,0.95f,0.92f,1.14f,0.98f,1.03f,0.79f,0.84f,0.77f,0.97f,0.90f,0.89f,0.76f,0.82f,0.82f,0.74f,0.72f,0.71f,0.98f,0.89f,0.97f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.60f,1.44f,1.68f,1.22f,1.49f,1.71f,0.93f,0.99f,0.99f,1.23f,1.22f,1.60f,1.68f,1.44f,1.49f,1.40f,1.14f,1.19f,0.89f,0.96f,0.89f,0.97f,0.89f,0.91f,0.98f,0.82f,0.76f,0.82f,0.71f,0.72f,0.73f,0.76f,0.79f,0.86f,0.83f,0.91f,0.83f,0.89f,0.72f,0.76f,0.76f,0.89f,0.89f,0.82f,0.82f,0.98f,0.96f,0.97f,1.14f,1.40f,1.19f,0.94f,1.00f,1.07f,1.37f,1.21f,1.48f,1.30f,1.57f,1.61f,1.37f,0.86f,0.83f,0.91f,0.82f,0.82f,0.88f,0.89f,0.96f,1.14f,0.98f,0.70f,0.72f,0.73f,0.77f,0.76f,0.79f,0.70f,0.72f,0.71f,0.82f,0.77f,0.80f,0.74f,0.79f,0.80f,0.74f,0.87f,0.93f,0.85f,1.23f,1.02f,1.02f,0.93f,0.93f,0.87f,0.85f,1.30f,1.35f,1.07f,1.38f,1.11f,0.94f,1.47f,1.71f,1.56f,1.97f,1.88f,1.92f,1.79f,1.79f,1.59f,1.60f,1.30f,1.35f,1.56f,1.37f,1.38f,1.59f,1.60f,1.79f,1.92f,1.79f,1.48f,1.57f,1.72f,1.61f,1.78f,1.79f,1.93f,1.99f,1.90f,1.86f,1.78f,1.86f,1.93f,1.99f,1.97f,1.90f,1.79f,1.72f,0.94f,1.07f,1.00f,1.37f,1.21f,1.30f,0.86f,0.91f,0.83f,1.14f,0.98f,0.96f,0.82f,0.88f,0.89f,0.79f,0.76f,0.73f,1.07f,0.94f,1.11f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.74f,1.57f,1.76f,1.33f,1.54f,1.71f,0.94f,1.05f,0.99f,1.26f,1.16f,1.46f,1.60f,1.34f,1.46f,1.59f,1.37f,1.37f,0.97f,1.11f,0.96f,1.10f,0.95f,0.94f,1.08f,0.89f,0.82f,0.88f,0.72f,0.76f,0.75f,0.80f,0.80f,0.88f,0.87f,0.91f,0.83f,0.87f,0.72f,0.76f,0.74f,0.83f,0.84f,0.78f,0.79f,0.96f,0.89f,0.92f,0.98f,1.23f,1.05f,0.86f,0.92f,0.95f,1.11f,0.98f,1.22f,1.03f,1.34f,1.42f,1.14f,0.79f,0.77f,0.84f,0.78f,0.76f,0.82f,0.82f,0.89f,0.97f,0.90f,0.70f,0.71f,0.71f,0.73f,0.72f,0.74f,0.73f,0.76f,0.72f,0.86f,0.81f,0.82f,0.76f,0.79f,0.77f,0.73f,0.90f,0.95f,0.86f,1.18f,1.03f,0.98f,0.92f,0.90f,0.83f,0.84f,1.19f,1.17f,0.98f,1.15f,0.97f,0.89f,1.42f,1.65f,1.44f,1.93f,1.83f,1.81f,1.67f,1.61f,1.36f,1.41f,1.32f,1.45f,1.58f,1.57f,1.53f,1.74f,1.70f,1.88f,1.94f,1.81f,1.69f,1.77f,1.87f,1.79f,1.89f,1.92f,1.98f,1.99f,1.98f,1.89f,1.65f,1.80f,1.82f,1.91f,1.94f,1.75f,1.61f,1.50f,1.07f,1.34f,1.27f,1.60f,1.45f,1.55f,0.93f,0.99f,0.90f,1.35f,1.18f,1.07f,0.87f,0.93f,0.96f,0.85f,0.82f,0.77f,1.15f,0.99f,1.27f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.86f,1.71f,1.82f,1.48f,1.62f,1.71f,0.98f,1.20f,1.05f,1.34f,1.17f,1.34f,1.53f,1.27f,1.46f,1.77f,1.60f,1.57f,1.16f,1.38f,1.12f,1.35f,1.06f,1.00f,1.28f,0.97f,0.89f,0.95f,0.76f,0.81f,0.79f,0.86f,0.85f,0.92f,0.93f,0.93f,0.85f,0.87f,0.74f,0.78f,0.74f,0.79f,0.82f,0.76f,0.79f,0.96f,0.85f,0.90f,0.94f,1.09f,0.99f,0.81f,0.85f,0.89f,0.95f,0.90f,0.99f,0.94f,1.10f,1.24f,0.98f,0.75f,0.73f,0.78f,0.74f,0.72f,0.77f,0.76f,0.82f,0.89f,0.83f,0.73f,0.71f,0.71f,0.71f,0.70f,0.72f,0.77f,0.80f,0.74f,0.90f,0.85f,0.84f,0.78f,0.79f,0.75f,0.73f,0.92f,0.95f,0.86f,1.05f,0.99f,0.94f,0.90f,0.86f,0.79f,0.81f,1.00f,0.98f,0.91f,0.96f,0.89f,0.83f,1.27f,1.50f,1.23f,1.80f,1.69f,1.63f,1.46f,1.37f,1.09f,1.16f,1.24f,1.44f,1.49f,1.69f,1.59f,1.80f,1.69f,1.87f,1.86f,1.72f,1.82f,1.91f,1.94f,1.92f,1.95f,1.99f,1.98f,1.91f,1.97f,1.89f,1.51f,1.72f,1.67f,1.77f,1.86f,1.55f,1.41f,1.25f,1.33f,1.58f,1.50f,1.80f,1.63f,1.74f,1.04f,1.21f,0.97f,1.48f,1.37f,1.21f,0.93f,0.97f,1.05f,0.92f,0.88f,0.84f,1.14f,1.02f,1.34f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.94f,1.84f,1.87f,1.64f,1.71f,1.71f,1.14f,1.38f,1.19f,1.46f,1.23f,1.26f,1.48f,1.26f,1.50f,1.91f,1.80f,1.76f,1.41f,1.61f,1.39f,1.59f,1.33f,1.24f,1.51f,1.18f,0.97f,1.11f,0.82f,0.88f,0.86f,0.94f,0.92f,0.99f,1.03f,0.98f,0.91f,0.90f,0.79f,0.84f,0.77f,0.79f,0.84f,0.77f,0.83f,0.99f,0.85f,0.91f,0.92f,1.02f,1.00f,0.79f,0.80f,0.86f,0.88f,0.84f,0.92f,0.88f,0.97f,1.10f,0.94f,0.74f,0.71f,0.74f,0.72f,0.70f,0.73f,0.72f,0.76f,0.82f,0.77f,0.77f,0.73f,0.74f,0.71f,0.70f,0.73f,0.83f,0.85f,0.78f,0.92f,0.88f,0.86f,0.81f,0.79f,0.74f,0.75f,0.92f,0.93f,0.85f,0.96f,0.94f,0.88f,0.86f,0.81f,0.75f,0.79f,0.93f,0.90f,0.85f,0.88f,0.82f,0.77f,1.05f,1.27f,0.99f,1.60f,1.47f,1.39f,1.20f,1.11f,0.95f,0.97f,1.08f,1.33f,1.31f,1.70f,1.55f,1.76f,1.57f,1.76f,1.70f,1.54f,1.85f,1.97f,1.91f,1.99f,1.97f,1.99f,1.91f,1.77f,1.88f,1.85f,1.39f,1.64f,1.51f,1.58f,1.74f,1.32f,1.22f,1.01f,1.54f,1.76f,1.65f,1.93f,1.70f,1.85f,1.28f,1.39f,1.09f,1.52f,1.48f,1.26f,0.97f,0.99f,1.18f,1.00f,0.93f,0.90f,1.05f,1.01f,1.31f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.97f,1.92f,1.88f,1.79f,1.79f,1.71f,1.37f,1.59f,1.38f,1.60f,1.35f,1.23f,1.47f,1.30f,1.56f,1.99f,1.93f,1.90f,1.60f,1.78f,1.61f,1.79f,1.57f,1.48f,1.72f,1.40f,1.14f,1.37f,0.89f,0.96f,0.94f,1.07f,1.00f,1.21f,1.30f,1.14f,0.98f,0.96f,0.86f,0.91f,0.83f,0.82f,0.88f,0.82f,0.89f,1.11f,0.87f,0.94f,0.93f,1.02f,1.07f,0.80f,0.79f,0.85f,0.82f,0.80f,0.87f,0.85f,0.93f,1.02f,0.93f,0.77f,0.72f,0.74f,0.71f,0.70f,0.70f,0.71f,0.72f,0.77f,0.74f,0.82f,0.76f,0.79f,0.72f,0.73f,0.76f,0.89f,0.89f,0.82f,0.93f,0.91f,0.86f,0.83f,0.79f,0.73f,0.76f,0.91f,0.89f,0.83f,0.89f,0.89f,0.82f,0.82f,0.76f,0.72f,0.76f,0.86f,0.83f,0.79f,0.82f,0.76f,0.73f,0.94f,1.00f,0.91f,1.37f,1.21f,1.14f,0.98f,0.96f,0.88f,0.89f,0.96f,1.14f,1.07f,1.60f,1.40f,1.61f,1.37f,1.57f,1.48f,1.30f,1.78f,1.93f,1.79f,1.99f,1.92f,1.90f,1.79f,1.59f,1.72f,1.79f,1.30f,1.56f,1.35f,1.38f,1.60f,1.11f,1.07f,0.94f,1.68f,1.86f,1.71f,1.97f,1.68f,1.86f,1.44f,1.49f,1.22f,1.44f,1.49f,1.22f,0.99f,0.99f,1.23f,1.19f,0.98f,0.97f,0.97f,0.98f,1.19f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.94f,1.97f,1.87f,1.91f,1.85f,1.71f,1.60f,1.77f,1.58f,1.74f,1.51f,1.26f,1.48f,1.39f,1.64f,1.99f,1.97f,1.99f,1.70f,1.85f,1.76f,1.91f,1.76f,1.70f,1.88f,1.55f,1.33f,1.57f,0.96f,1.08f,1.05f,1.31f,1.27f,1.47f,1.54f,1.39f,1.20f,1.11f,0.93f,0.99f,0.90f,0.88f,0.95f,0.88f,0.97f,1.32f,0.92f,1.01f,0.97f,1.10f,1.22f,0.84f,0.80f,0.88f,0.79f,0.79f,0.85f,0.86f,0.92f,1.02f,0.94f,0.82f,0.76f,0.77f,0.72f,0.73f,0.70f,0.72f,0.71f,0.74f,0.74f,0.88f,0.81f,0.85f,0.75f,0.77f,0.82f,0.94f,0.93f,0.86f,0.92f,0.92f,0.86f,0.85f,0.79f,0.74f,0.79f,0.88f,0.85f,0.81f,0.82f,0.83f,0.77f,0.78f,0.73f,0.71f,0.75f,0.79f,0.77f,0.74f,0.77f,0.73f,0.70f,0.86f,0.92f,0.84f,1.14f,0.99f,0.98f,0.91f,0.90f,0.84f,0.83f,0.88f,0.97f,0.94f,1.41f,1.18f,1.39f,1.11f,1.33f,1.24f,1.03f,1.61f,1.80f,1.59f,1.91f,1.84f,1.76f,1.64f,1.38f,1.51f,1.71f,1.26f,1.50f,1.23f,1.19f,1.46f,0.99f,1.00f,0.91f,1.70f,1.85f,1.65f,1.93f,1.54f,1.76f,1.52f,1.48f,1.26f,1.28f,1.39f,1.09f,0.99f,0.97f,1.18f,1.31f,1.01f,1.05f,0.90f,0.93f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.86f,1.95f,1.82f,1.98f,1.89f,1.71f,1.80f,1.91f,1.77f,1.86f,1.67f,1.34f,1.53f,1.51f,1.72f,1.92f,1.91f,1.99f,1.69f,1.82f,1.80f,1.94f,1.87f,1.86f,1.97f,1.59f,1.44f,1.69f,1.05f,1.24f,1.27f,1.49f,1.50f,1.69f,1.72f,1.63f,1.46f,1.37f,1.00f,1.23f,0.98f,0.95f,1.09f,0.96f,1.16f,1.55f,0.99f,1.25f,1.10f,1.24f,1.41f,0.90f,0.85f,0.94f,0.79f,0.81f,0.85f,0.89f,0.94f,1.09f,0.98f,0.89f,0.82f,0.83f,0.74f,0.77f,0.72f,0.76f,0.73f,0.75f,0.78f,0.94f,0.86f,0.91f,0.79f,0.83f,0.89f,0.99f,0.95f,0.90f,0.90f,0.92f,0.84f,0.86f,0.79f,0.75f,0.81f,0.85f,0.80f,0.78f,0.76f,0.77f,0.73f,0.74f,0.71f,0.71f,0.73f,0.74f,0.74f,0.71f,0.76f,0.72f,0.70f,0.79f,0.85f,0.78f,0.98f,0.92f,0.93f,0.85f,0.87f,0.82f,0.79f,0.81f,0.89f,0.86f,1.16f,0.97f,1.12f,0.95f,1.06f,1.00f,0.93f,1.38f,1.60f,1.35f,1.77f,1.71f,1.57f,1.48f,1.20f,1.28f,1.62f,1.27f,1.46f,1.17f,1.05f,1.34f,0.96f,0.99f,0.90f,1.63f,1.74f,1.50f,1.80f,1.33f,1.58f,1.48f,1.37f,1.21f,1.04f,1.21f,0.97f,0.97f,0.93f,1.05f,1.34f,1.02f,1.14f,0.84f,0.88f,0.92f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.74f,1.89f,1.76f,1.98f,1.89f,1.71f,1.93f,1.99f,1.91f,1.94f,1.82f,1.46f,1.60f,1.65f,1.80f,1.79f,1.77f,1.92f,1.57f,1.69f,1.74f,1.87f,1.88f,1.94f,1.98f,1.53f,1.45f,1.70f,1.18f,1.32f,1.42f,1.58f,1.65f,1.83f,1.81f,1.81f,1.67f,1.61f,1.19f,1.44f,1.17f,1.11f,1.36f,1.15f,1.41f,1.75f,1.22f,1.50f,1.34f,1.42f,1.61f,0.98f,0.92f,1.03f,0.83f,0.86f,0.89f,0.95f,0.98f,1.23f,1.14f,0.97f,0.89f,0.90f,0.78f,0.82f,0.76f,0.82f,0.77f,0.79f,0.84f,0.98f,0.90f,0.98f,0.83f,0.89f,0.97f,1.03f,0.95f,0.92f,0.86f,0.90f,0.82f,0.86f,0.79f,0.77f,0.84f,0.81f,0.76f,0.76f,0.72f,0.73f,0.70f,0.72f,0.71f,0.73f,0.73f,0.72f,0.74f,0.71f,0.78f,0.74f,0.72f,0.75f,0.80f,0.76f,0.94f,0.88f,0.91f,0.83f,0.87f,0.84f,0.79f,0.76f,0.82f,0.80f,0.97f,0.89f,0.96f,0.88f,0.95f,0.94f,0.87f,1.11f,1.37f,1.10f,1.59f,1.57f,1.37f,1.33f,1.05f,1.08f,1.54f,1.34f,1.46f,1.16f,0.99f,1.26f,0.96f,1.05f,0.92f,1.45f,1.55f,1.27f,1.60f,1.07f,1.34f,1.35f,1.18f,1.07f,0.93f,0.99f,0.90f,0.93f,0.87f,0.96f,1.27f,0.99f,1.15f,0.77f,0.82f,0.85f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.60f,1.78f,1.68f,1.93f,1.86f,1.71f,1.97f,1.99f,1.99f,1.97f,1.93f,1.60f,1.68f,1.78f,1.86f,1.61f,1.57f,1.79f,1.37f,1.48f,1.59f,1.72f,1.79f,1.92f,1.90f,1.38f,1.35f,1.60f,1.23f,1.30f,1.47f,1.56f,1.71f,1.88f,1.79f,1.92f,1.79f,1.79f,1.30f,1.56f,1.35f,1.37f,1.59f,1.38f,1.60f,1.90f,1.48f,1.72f,1.57f,1.61f,1.79f,1.21f,1.00f,1.30f,0.89f,0.94f,0.96f,1.07f,1.14f,1.40f,1.37f,1.14f,0.96f,0.98f,0.82f,0.88f,0.82f,0.89f,0.83f,0.86f,0.91f,1.02f,0.93f,1.07f,0.87f,0.94f,1.11f,1.02f,0.93f,0.93f,0.82f,0.87f,0.80f,0.85f,0.79f,0.80f,0.85f,0.77f,0.72f,0.74f,0.71f,0.70f,0.70f,0.71f,0.72f,0.77f,0.74f,0.72f,0.76f,0.73f,0.82f,0.79f,0.76f,0.73f,0.79f,0.76f,0.93f,0.86f,0.91f,0.83f,0.89f,0.89f,0.82f,0.72f,0.76f,0.76f,0.89f,0.82f,0.89f,0.82f,0.89f,0.91f,0.83f,0.96f,1.14f,0.97f,1.40f,1.44f,1.19f,1.22f,0.99f,0.98f,1.49f,1.44f,1.49f,1.22f,0.99f,1.23f,0.98f,1.19f,0.97f,1.21f,1.30f,1.00f,1.37f,0.94f,1.07f,1.14f,0.98f,0.96f,0.86f,0.91f,0.83f,0.88f,0.82f,0.89f,1.11f,0.94f,1.07f,0.73f,0.76f,0.79f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.46f,1.65f,1.60f,1.82f,1.80f,1.71f,1.93f,1.91f,1.99f,1.94f,1.98f,1.74f,1.76f,1.89f,1.89f,1.42f,1.34f,1.61f,1.11f,1.22f,1.36f,1.50f,1.61f,1.81f,1.75f,1.15f,1.17f,1.41f,1.18f,1.19f,1.42f,1.44f,1.65f,1.83f,1.67f,1.94f,1.81f,1.88f,1.32f,1.58f,1.45f,1.57f,1.74f,1.53f,1.70f,1.98f,1.69f,1.87f,1.77f,1.79f,1.92f,1.45f,1.27f,1.55f,0.97f,1.07f,1.11f,1.34f,1.37f,1.59f,1.60f,1.35f,1.07f,1.18f,0.86f,0.93f,0.87f,0.96f,0.90f,0.93f,0.99f,1.03f,0.95f,1.15f,0.90f,0.99f,1.27f,0.98f,0.90f,0.92f,0.78f,0.83f,0.77f,0.84f,0.79f,0.82f,0.86f,0.73f,0.71f,0.73f,0.72f,0.70f,0.73f,0.72f,0.76f,0.81f,0.76f,0.76f,0.82f,0.77f,0.89f,0.85f,0.82f,0.75f,0.80f,0.80f,0.94f,0.88f,0.94f,0.87f,0.95f,0.96f,0.88f,0.72f,0.74f,0.76f,0.83f,0.78f,0.84f,0.79f,0.87f,0.91f,0.83f,0.89f,0.98f,0.92f,1.23f,1.34f,1.05f,1.16f,0.99f,0.96f,1.46f,1.57f,1.54f,1.33f,1.05f,1.26f,1.08f,1.37f,1.10f,0.98f,1.03f,0.92f,1.14f,0.86f,0.95f,0.97f,0.90f,0.89f,0.79f,0.84f,0.77f,0.82f,0.76f,0.82f,0.97f,0.89f,0.98f,0.71f,0.72f,0.74f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.34f,1.51f,1.53f,1.67f,1.72f,1.71f,1.80f,1.77f,1.91f,1.86f,1.98f,1.86f,1.82f,1.95f,1.89f,1.24f,1.10f,1.41f,0.95f,0.99f,1.09f,1.25f,1.37f,1.63f,1.55f,0.96f,0.98f,1.16f,1.05f,1.00f,1.27f,1.23f,1.50f,1.69f,1.46f,1.86f,1.72f,1.87f,1.24f,1.49f,1.44f,1.69f,1.80f,1.59f,1.69f,1.97f,1.82f,1.94f,1.91f,1.92f,1.99f,1.63f,1.50f,1.74f,1.16f,1.33f,1.38f,1.58f,1.60f,1.77f,1.80f,1.48f,1.21f,1.37f,0.90f,0.97f,0.93f,1.05f,0.97f,1.04f,1.21f,0.99f,0.95f,1.14f,0.92f,1.02f,1.34f,0.94f,0.86f,0.90f,0.74f,0.79f,0.75f,0.81f,0.79f,0.84f,0.86f,0.71f,0.71f,0.73f,0.76f,0.73f,0.77f,0.74f,0.80f,0.85f,0.78f,0.81f,0.89f,0.84f,0.97f,0.92f,0.88f,0.79f,0.85f,0.86f,0.98f,0.92f,1.00f,0.93f,1.06f,1.12f,0.95f,0.74f,0.74f,0.78f,0.79f,0.76f,0.82f,0.79f,0.87f,0.93f,0.85f,0.85f,0.94f,0.90f,1.09f,1.27f,0.99f,1.17f,1.05f,0.96f,1.46f,1.71f,1.62f,1.48f,1.20f,1.34f,1.28f,1.57f,1.35f,0.90f,0.94f,0.85f,0.98f,0.81f,0.89f,0.89f,0.83f,0.82f,0.75f,0.78f,0.73f,0.77f,0.72f,0.76f,0.89f,0.83f,0.91f,0.71f,0.70f,0.72f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f},
+ {1.26f,1.39f,1.48f,1.51f,1.64f,1.71f,1.60f,1.58f,1.77f,1.74f,1.91f,1.94f,1.87f,1.97f,1.85f,1.10f,0.97f,1.22f,0.88f,0.92f,0.95f,1.01f,1.11f,1.39f,1.32f,0.88f,0.90f,0.97f,0.96f,0.93f,1.05f,0.99f,1.27f,1.47f,1.20f,1.70f,1.54f,1.76f,1.08f,1.31f,1.33f,1.70f,1.76f,1.55f,1.57f,1.88f,1.85f,1.91f,1.97f,1.99f,1.99f,1.70f,1.65f,1.85f,1.41f,1.54f,1.61f,1.76f,1.80f,1.91f,1.93f,1.52f,1.26f,1.48f,0.92f,0.99f,0.97f,1.18f,1.09f,1.28f,1.39f,0.94f,0.93f,1.05f,0.92f,1.01f,1.31f,0.88f,0.81f,0.86f,0.72f,0.75f,0.74f,0.79f,0.79f,0.86f,0.85f,0.71f,0.73f,0.75f,0.82f,0.77f,0.83f,0.78f,0.85f,0.88f,0.81f,0.88f,0.97f,0.90f,1.18f,1.00f,0.93f,0.86f,0.92f,0.94f,1.14f,0.99f,1.24f,1.03f,1.33f,1.39f,1.11f,0.79f,0.77f,0.84f,0.79f,0.77f,0.84f,0.83f,0.90f,0.98f,0.91f,0.85f,0.92f,0.91f,1.02f,1.26f,1.00f,1.23f,1.19f,0.99f,1.50f,1.84f,1.71f,1.64f,1.38f,1.46f,1.51f,1.76f,1.59f,0.84f,0.88f,0.80f,0.94f,0.79f,0.86f,0.82f,0.77f,0.76f,0.74f,0.74f,0.71f,0.73f,0.70f,0.72f,0.82f,0.77f,0.85f,0.74f,0.70f,0.73f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}
+ };
+
+}
diff --git a/src/jake2/render/fastjogl/Base.java b/src/jake2/render/fastjogl/Base.java
new file mode 100644
index 0000000..c5cc690
--- /dev/null
+++ b/src/jake2/render/fastjogl/Base.java
@@ -0,0 +1,300 @@
+/*
+ * Base.java
+ * Copyright (C) 2003
+ *
+ * $Id: Base.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import net.java.games.jogl.GL;
+
+/**
+ * Base
+ *
+ * @author cwei
+ */
+public class Base {
+
+ static final int GL_COLOR_INDEX8_EXT = GL.GL_COLOR_INDEX;
+ static final String REF_VERSION = "GL 0.01";
+
+ // up / down
+ static final int PITCH = 0;
+ // left / right
+ static final int YAW = 1;
+ // fall over
+ static final int ROLL = 2;
+
+ /*
+ skins will be outline flood filled and mip mapped
+ pics and sprites with alpha will be outline flood filled
+ pic won't be mip mapped
+
+ model skin
+ sprite frame
+ wall texture
+ pic
+ */
+ // enum imagetype_t
+ static final int it_skin = 0;
+ static final int it_sprite = 1;
+ static final int it_wall = 2;
+ static final int it_pic = 3;
+ static final int it_sky = 4;
+
+ // enum modtype_t
+ static final int mod_bad = 0;
+ static final int mod_brush = 1;
+ static final int mod_sprite = 2;
+ static final int mod_alias = 3;
+
+ static final int TEXNUM_LIGHTMAPS = 1024;
+ static final int TEXNUM_SCRAPS = 1152;
+ static final int TEXNUM_IMAGES = 1153;
+
+ static final int MAX_GLTEXTURES = 1024;
+
+// ===================================================================
+
+ // enum rserr_t
+ static final int rserr_ok = 0;
+ static final int rserr_invalid_fullscreen = 1;
+ static final int rserr_invalid_mode = 2;
+ static final int rserr_unknown = 3;
+
+//
+// #include "gl_model.h"
+//
+// void GL_BeginRendering (int *x, int *y, int *width, int *height);
+// void GL_EndRendering (void);
+//
+// void GL_SetDefaultState( void );
+// void GL_UpdateSwapInterval( void );
+
+ static class glvert_t {
+ float x, y, z;
+ float s, t;
+ float r, g, b;
+ }
+
+ static final int MAX_LBM_HEIGHT = 480;
+
+ static final float BACKFACE_EPSILON = 0.01f;
+
+// ====================================================
+//
+// void R_TranslatePlayerSkin (int playernum);
+// void GL_Bind (int texnum);
+// void GL_MBind( GLenum target, int texnum );
+// void GL_TexEnv( GLenum value );
+// void GL_EnableMultitexture( qboolean enable );
+// void GL_SelectTexture( GLenum );
+//
+// void R_LightPoint (vec3_t p, vec3_t color);
+// void R_PushDlights (void);
+//
+
+// ====================================================================
+//
+// extern int registration_sequence;
+//
+//
+// void V_AddBlend (float r, float g, float b, float a, float *v_blend);
+//
+// int R_Init( void *hinstance, void *hWnd );
+// void R_Shutdown( void );
+//
+// void R_RenderView (refdef_t *fd);
+// void GL_ScreenShot_f (void);
+// void R_DrawAliasModel (entity_t *e);
+// void R_DrawBrushModel (entity_t *e);
+// void R_DrawSpriteModel (entity_t *e);
+// void R_DrawBeam( entity_t *e );
+// void R_DrawWorld (void);
+// void R_RenderDlights (void);
+// void R_DrawAlphaSurfaces (void);
+// void R_RenderBrushPoly (msurface_t *fa);
+// void R_InitParticleTexture (void);
+// void Draw_InitLocal (void);
+// void GL_SubdivideSurface (msurface_t *fa);
+// qboolean R_CullBox (vec3_t mins, vec3_t maxs);
+// void R_RotateForEntity (entity_t *e);
+// void R_MarkLeaves (void);
+//
+// glpoly_t *WaterWarpPolyVerts (glpoly_t *p);
+// void EmitWaterPolys (msurface_t *fa);
+// void R_AddSkySurface (msurface_t *fa);
+// void R_ClearSkyBox (void);
+// void R_DrawSkyBox (void);
+// void R_MarkLights (dlight_t *light, int bit, mnode_t *node);
+//
+//
+// void COM_StripExtension (char *in, char *out);
+//
+// void Draw_GetPicSize (int *w, int *h, char *name);
+// void Draw_Pic (int x, int y, char *name);
+// void Draw_StretchPic (int x, int y, int w, int h, char *name);
+// void Draw_Char (int x, int y, int c);
+// void Draw_TileClear (int x, int y, int w, int h, char *name);
+// void Draw_Fill (int x, int y, int w, int h, int c);
+// void Draw_FadeScreen (void);
+// void Draw_StretchRaw (int x, int y, int w, int h, int cols, int rows, byte *data);
+//
+// void R_BeginFrame( float camera_separation );
+// void R_SwapBuffers( int );
+// void R_SetPalette ( const unsigned char *palette);
+//
+// int Draw_GetPalette (void);
+//
+// void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight);
+//
+// struct image_s *R_RegisterSkin (char *name);
+//
+// void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height);
+// image_t *GL_LoadPic (char *name, byte *pic, int width, int height, imagetype_t type, int bits);
+// image_t *GL_FindImage (char *name, imagetype_t type);
+// void GL_TextureMode( char *string );
+// void GL_ImageList_f (void);
+//
+// void GL_SetTexturePalette( unsigned palette[256] );
+//
+// void GL_InitImages (void);
+// void GL_ShutdownImages (void);
+//
+// void GL_FreeUnusedImages (void);
+//
+// void GL_TextureAlphaMode( char *string );
+// void GL_TextureSolidMode( char *string );
+//
+// /*
+// ** GL extension emulation functions
+// */
+// void GL_DrawParticles( int n, const particle_t particles[], const unsigned colortable[768] );
+//
+
+ /*
+ ** GL config stuff
+ */
+ static final int GL_RENDERER_VOODOO = 0x00000001;
+ static final int GL_RENDERER_VOODOO2 = 0x00000002;
+ static final int GL_RENDERER_VOODOO_RUSH = 0x00000004;
+ static final int GL_RENDERER_BANSHEE = 0x00000008;
+ static final int GL_RENDERER_3DFX = 0x0000000F;
+
+ static final int GL_RENDERER_PCX1 = 0x00000010;
+ static final int GL_RENDERER_PCX2 = 0x00000020;
+ static final int GL_RENDERER_PMX = 0x00000040;
+ static final int GL_RENDERER_POWERVR = 0x00000070;
+
+ static final int GL_RENDERER_PERMEDIA2 = 0x00000100;
+ static final int GL_RENDERER_GLINT_MX = 0x00000200;
+ static final int GL_RENDERER_GLINT_TX = 0x00000400;
+ static final int GL_RENDERER_3DLABS_MISC = 0x00000800;
+ static final int GL_RENDERER_3DLABS = 0x00000F00;
+
+ static final int GL_RENDERER_REALIZM = 0x00001000;
+ static final int GL_RENDERER_REALIZM2 = 0x00002000;
+ static final int GL_RENDERER_INTERGRAPH = 0x00003000;
+
+ static final int GL_RENDERER_3DPRO = 0x00004000;
+ static final int GL_RENDERER_REAL3D = 0x00008000;
+ static final int GL_RENDERER_RIVA128 = 0x00010000;
+ static final int GL_RENDERER_DYPIC = 0x00020000;
+
+ static final int GL_RENDERER_V1000 = 0x00040000;
+ static final int GL_RENDERER_V2100 = 0x00080000;
+ static final int GL_RENDERER_V2200 = 0x00100000;
+ static final int GL_RENDERER_RENDITION = 0x001C0000;
+
+ static final int GL_RENDERER_O2 = 0x00100000;
+ static final int GL_RENDERER_IMPACT = 0x00200000;
+ static final int GL_RENDERER_RE = 0x00400000;
+ static final int GL_RENDERER_IR = 0x00800000;
+ static final int GL_RENDERER_SGI = 0x00F00000;
+
+ static final int GL_RENDERER_MCD = 0x01000000;
+ static final int GL_RENDERER_OTHER = 0x80000000;
+
+
+// typedef struct
+// {
+// int renderer;
+// const char *renderer_string;
+// const char *vendor_string;
+// const char *version_string;
+// const char *extensions_string;
+//
+// qboolean allow_cds;
+// } glconfig_t;
+//
+// typedef struct
+// {
+// float inverse_intensity;
+// qboolean fullscreen;
+//
+// int prev_mode;
+//
+// unsigned char *d_16to8table;
+//
+// int lightmap_textures;
+//
+// int currenttextures[2];
+// int currenttmu;
+//
+// float camera_separation;
+// qboolean stereo_enabled;
+//
+// unsigned char originalRedGammaTable[256];
+// unsigned char originalGreenGammaTable[256];
+// unsigned char originalBlueGammaTable[256];
+// } glstate_t;
+//
+// /*
+// ====================================================================
+//
+// IMPORTED FUNCTIONS
+//
+// ====================================================================
+// */
+//
+// extern refimport_t ri;
+//
+//
+// /*
+// ====================================================================
+//
+// IMPLEMENTATION SPECIFIC FUNCTIONS
+//
+// ====================================================================
+// */
+//
+// void GLimp_BeginFrame( float camera_separation );
+// void GLimp_EndFrame( void );
+// int GLimp_Init( void *hinstance, void *hWnd );
+// void GLimp_Shutdown( void );
+// int GLimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen );
+// void GLimp_AppActivate( qboolean active );
+// void GLimp_EnableLogging( qboolean enable );
+// void GLimp_LogNewFrame( void );
+//
+
+}
diff --git a/src/jake2/render/fastjogl/Draw.java b/src/jake2/render/fastjogl/Draw.java
new file mode 100644
index 0000000..fcb48b6
--- /dev/null
+++ b/src/jake2/render/fastjogl/Draw.java
@@ -0,0 +1,406 @@
+/*
+ * Draw.java
+ * Copyright (C) 2003
+ *
+ * $Id: Draw.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.render.image_t;
+
+import java.awt.Dimension;
+
+import net.java.games.jogl.GL;
+import net.java.games.jogl.util.GLUT;
+
+/**
+ * Draw
+ * (gl_draw.c)
+ *
+ * @author cwei
+ */
+public abstract class Draw extends Image {
+
+ /*
+ ===============
+ Draw_InitLocal
+ ===============
+ */
+ void Draw_InitLocal() {
+ // load console characters (don't bilerp characters)
+ draw_chars = GL_FindImage("pics/conchars.pcx", it_pic);
+ GL_Bind(draw_chars.texnum);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+ }
+
+ /*
+ ================
+ Draw_Char
+
+ Draws one 8*8 graphics character with 0 being transparent.
+ It can be clipped to the top of the screen to allow the console to be
+ smoothly scrolled off.
+ ================
+ */
+ protected void Draw_Char(int x, int y, int num) {
+
+ num &= 255;
+
+ if ( (num&127) == 32 ) return; // space
+
+ if (y <= -8) return; // totally off screen
+
+ int row = num>>4;
+ int col = num&15;
+
+ float frow = row*0.0625f;
+ float fcol = col*0.0625f;
+ float size = 0.0625f;
+
+ GL_Bind(draw_chars.texnum);
+
+ gl.glBegin (GL.GL_QUADS);
+ gl.glTexCoord2f (fcol, frow);
+ gl.glVertex2f (x, y);
+ gl.glTexCoord2f (fcol + size, frow);
+ gl.glVertex2f (x+8, y);
+ gl.glTexCoord2f (fcol + size, frow + size);
+ gl.glVertex2f (x+8, y+8);
+ gl.glTexCoord2f (fcol, frow + size);
+ gl.glVertex2f (x, y+8);
+ gl.glEnd ();
+ }
+
+
+ /*
+ =============
+ Draw_FindPic
+ =============
+ */
+ protected image_t Draw_FindPic(String name) {
+ image_t image = null;
+ String fullname;
+
+ if (!name.startsWith("/") && !name.startsWith("\\"))
+ {
+ fullname = "pics/" + name + ".pcx";
+ image = GL_FindImage(fullname, it_pic);
+ } else {
+ image = GL_FindImage(name.substring(1), it_pic);
+ }
+ return image;
+ }
+
+
+ /*
+ =============
+ Draw_GetPicSize
+ =============
+ */
+ protected void Draw_GetPicSize(Dimension dim, String pic) {
+
+ image_t image = Draw_FindPic(pic);
+ dim.width = (image != null) ? image.width : -1;
+ dim.height = (image != null) ? image.height : -1;
+ }
+
+ /*
+ =============
+ Draw_StretchPic
+ =============
+ */
+ protected void Draw_StretchPic (int x, int y, int w, int h, String pic) {
+
+ image_t image;
+
+ image = Draw_FindPic(pic);
+ if (image == null)
+ {
+ ri.Con_Printf (Defines.PRINT_ALL, "Can't find pic: " + pic +'\n');
+ return;
+ }
+
+ if (scrap_dirty)
+ Scrap_Upload();
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0) ) && !image.has_alpha)
+ gl.glDisable(GL.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+ gl.glBegin (GL.GL_QUADS);
+ gl.glTexCoord2f (image.sl, image.tl);
+ gl.glVertex2f (x, y);
+ gl.glTexCoord2f (image.sh, image.tl);
+ gl.glVertex2f (x+w, y);
+ gl.glTexCoord2f (image.sh, image.th);
+ gl.glVertex2f (x+w, y+h);
+ gl.glTexCoord2f (image.sl, image.th);
+ gl.glVertex2f (x, y+h);
+ gl.glEnd ();
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) !=0 ) ) && !image.has_alpha)
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ }
+
+
+ /*
+ =============
+ Draw_Pic
+ =============
+ */
+ protected void Draw_Pic(int x, int y, String pic)
+ {
+ image_t image;
+
+ image = Draw_FindPic(pic);
+ if (image == null)
+ {
+ ri.Con_Printf(Defines.PRINT_ALL, "Can't find pic: " +pic + '\n');
+ return;
+ }
+ if (scrap_dirty)
+ Scrap_Upload();
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha)
+ gl.glDisable (GL.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+
+ gl.glBegin (GL.GL_QUADS);
+ gl.glTexCoord2f (image.sl, image.tl);
+ gl.glVertex2f (x, y);
+ gl.glTexCoord2f (image.sh, image.tl);
+ gl.glVertex2f (x+image.width, y);
+ gl.glTexCoord2f (image.sh, image.th);
+ gl.glVertex2f (x+image.width, y+image.height);
+ gl.glTexCoord2f (image.sl, image.th);
+ gl.glVertex2f (x, y+image.height);
+ gl.glEnd ();
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha)
+ gl.glEnable (GL.GL_ALPHA_TEST);
+ }
+
+ /*
+ =============
+ Draw_TileClear
+
+ This repeats a 64*64 tile graphic to fill the screen around a sized down
+ refresh window.
+ =============
+ */
+ protected void Draw_TileClear(int x, int y, int w, int h, String pic) {
+ image_t image;
+
+ image = Draw_FindPic(pic);
+ if (image == null)
+ {
+ ri.Con_Printf(Defines.PRINT_ALL, "Can't find pic: " + pic + '\n');
+ return;
+ }
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha)
+ gl.glDisable(GL.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+ gl.glBegin (GL.GL_QUADS);
+ gl.glTexCoord2f(x/64.0f, y/64.0f);
+ gl.glVertex2f (x, y);
+ gl.glTexCoord2f( (x+w)/64.0f, y/64.0f);
+ gl.glVertex2f(x+w, y);
+ gl.glTexCoord2f( (x+w)/64.0f, (y+h)/64.0f);
+ gl.glVertex2f(x+w, y+h);
+ gl.glTexCoord2f( x/64.0f, (y+h)/64.0f );
+ gl.glVertex2f (x, y+h);
+ gl.glEnd ();
+
+ if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha)
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ }
+
+
+ /*
+ =============
+ Draw_Fill
+
+ Fills a box of pixels with a single color
+ =============
+ */
+ protected void Draw_Fill(int x, int y, int w, int h, int colorIndex) {
+
+ if ( colorIndex > 255)
+ ri.Sys_Error(Defines.ERR_FATAL, "Draw_Fill: bad color");
+
+ gl.glDisable(GL.GL_TEXTURE_2D);
+
+ int color = d_8to24table[colorIndex];
+
+ gl.glColor3ub(
+ (byte)((color >> 0) & 0xff), // r
+ (byte)((color >> 8) & 0xff), // g
+ (byte)((color >> 16) & 0xff) // b
+ );
+
+ gl.glBegin (GL.GL_QUADS);
+
+ gl.glVertex2f(x,y);
+ gl.glVertex2f(x+w, y);
+ gl.glVertex2f(x+w, y+h);
+ gl.glVertex2f(x, y+h);
+
+ gl.glEnd();
+ gl.glColor3f(1,1,1);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ }
+
+// =============================================================================
+
+ /*
+ ================
+ Draw_FadeScreen
+ ================
+ */
+ protected void Draw_FadeScreen() {
+ gl.glEnable(GL.GL_BLEND);
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ gl.glColor4f(0, 0, 0, 0.8f);
+ gl.glBegin(GL.GL_QUADS);
+
+ gl.glVertex2f(0,0);
+ gl.glVertex2f(vid.width, 0);
+ gl.glVertex2f(vid.width, vid.height);
+ gl.glVertex2f(0, vid.height);
+
+ gl.glEnd();
+ gl.glColor4f(1,1,1,1);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ gl.glDisable(GL.GL_BLEND);
+ }
+
+// ====================================================================
+
+
+ /*
+ =============
+ Draw_StretchRaw
+ =============
+ */
+ protected void Draw_StretchRaw (int x, int y, int w, int h, int cols, int rows, byte[] data)
+ {
+ int i, j, trows;
+ int sourceIndex;
+ int frac, fracstep;
+ float hscale;
+ int row;
+ float t;
+
+ GL_Bind(0);
+
+ if (rows<=256)
+ {
+ hscale = 1;
+ trows = rows;
+ }
+ else
+ {
+ hscale = rows/256.0f;
+ trows = 256;
+ }
+ t = rows*hscale / 256;
+
+ if ( !qglColorTableEXT )
+ {
+ int[] image32 = new int[256*256];
+ int destIndex = 0;
+
+ for (i=0 ; i<trows ; i++)
+ {
+ row = (int)(i*hscale);
+ if (row > rows)
+ break;
+ sourceIndex = cols*row;
+ destIndex = i*256;
+ fracstep = cols*0x10000/256;
+ frac = fracstep >> 1;
+ for (j=0 ; j<256 ; j++)
+ {
+ image32[destIndex + j] = r_rawpalette[data[sourceIndex + (frac>>16)] & 0xff];
+ frac += fracstep;
+ }
+ }
+ gl.glTexImage2D (GL.GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, image32);
+ }
+ else
+ {
+ byte[] image8 = new byte[256*256];
+ int destIndex = 0;;
+
+ for (i=0 ; i<trows ; i++)
+ {
+ row = (int)(i*hscale);
+ if (row > rows)
+ break;
+ sourceIndex = cols*row;
+ destIndex = i*256;
+ fracstep = cols*0x10000/256;
+ frac = fracstep >> 1;
+ for (j=0 ; j<256 ; j++)
+ {
+ image8[destIndex + j] = data[sourceIndex + (frac>>16)];
+ frac += fracstep;
+ }
+ }
+
+ gl.glTexImage2D( GL.GL_TEXTURE_2D,
+ 0,
+ GL_COLOR_INDEX8_EXT,
+ 256, 256,
+ 0,
+ GL.GL_COLOR_INDEX,
+ GL.GL_UNSIGNED_BYTE,
+ image8 );
+ }
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+
+ if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) )
+ gl.glDisable (GL.GL_ALPHA_TEST);
+
+ gl.glBegin (GL.GL_QUADS);
+ gl.glTexCoord2f (0, 0);
+ gl.glVertex2f (x, y);
+ gl.glTexCoord2f (1, 0);
+ gl.glVertex2f (x+w, y);
+ gl.glTexCoord2f (1, t);
+ gl.glVertex2f (x+w, y+h);
+ gl.glTexCoord2f (0, t);
+ gl.glVertex2f (x, y+h);
+ gl.glEnd ();
+
+ if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) )
+ gl.glEnable (GL.GL_ALPHA_TEST);
+ }
+
+}
diff --git a/src/jake2/render/fastjogl/Image.java b/src/jake2/render/fastjogl/Image.java
new file mode 100644
index 0000000..de364c3
--- /dev/null
+++ b/src/jake2/render/fastjogl/Image.java
@@ -0,0 +1,1673 @@
+/*
+ * Image.java
+ * Copyright (C) 2003
+ *
+ * $Id: Image.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.client.particle_t;
+import jake2.game.cvar_t;
+import jake2.qcommon.longjmpException;
+import jake2.qcommon.qfiles;
+import jake2.render.image_t;
+import jake2.util.Lib;
+import jake2.util.Vargs;
+
+import java.awt.Dimension;
+import java.awt.geom.AffineTransform;
+import java.awt.image.AffineTransformOp;
+import java.awt.image.BufferedImage;
+import java.nio.*;
+import java.util.Arrays;
+
+import net.java.games.jogl.GL;
+
+/**
+ * Image
+ *
+ * @author cwei
+ */
+public abstract class Image extends Main {
+
+ image_t draw_chars;
+
+ image_t[] gltextures = new image_t[MAX_GLTEXTURES];
+ //Map gltextures = new Hashtable(MAX_GLTEXTURES); // image_t
+ int numgltextures;
+ int base_textureid; // gltextures[i] = base_textureid+i
+
+ byte[] intensitytable = new byte[256];
+ byte[] gammatable = new byte[256];
+
+ cvar_t intensity;
+
+ //
+ // qboolean GL_Upload8 (byte *data, int width, int height, qboolean mipmap, qboolean is_sky );
+ // qboolean GL_Upload32 (unsigned *data, int width, int height, qboolean mipmap);
+ //
+
+ int gl_solid_format = 3;
+ int gl_alpha_format = 4;
+
+ int gl_tex_solid_format = 3;
+ int gl_tex_alpha_format = 4;
+
+ int gl_filter_min = GL.GL_LINEAR_MIPMAP_NEAREST;
+ int gl_filter_max = GL.GL_LINEAR;
+
+ Image() {
+ // init the texture cache
+ for (int i = 0; i < gltextures.length; i++)
+ {
+ gltextures[i] = new image_t(i);
+ }
+ numgltextures = 0;
+ }
+
+ void GL_SetTexturePalette(int[] palette) {
+
+ assert(palette != null && palette.length == 256) : "int palette[256] bug";
+
+ int i;
+ byte[] temptable = new byte[768];
+
+ if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) {
+ for (i = 0; i < 256; i++) {
+ temptable[i * 3 + 0] = (byte) ((palette[i] >> 0) & 0xff);
+ temptable[i * 3 + 1] = (byte) ((palette[i] >> 8) & 0xff);
+ temptable[i * 3 + 2] = (byte) ((palette[i] >> 16) & 0xff);
+ }
+
+ gl.glColorTableEXT(GL.GL_SHARED_TEXTURE_PALETTE_EXT, GL.GL_RGB, 256, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, temptable);
+ }
+ }
+
+ void GL_EnableMultitexture(boolean enable) {
+ if (enable) {
+ GL_SelectTexture(GL_TEXTURE1);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ GL_TexEnv(GL.GL_REPLACE);
+ }
+ else {
+ GL_SelectTexture(GL_TEXTURE1);
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ GL_TexEnv(GL.GL_REPLACE);
+ }
+ GL_SelectTexture(GL_TEXTURE0);
+ GL_TexEnv(GL.GL_REPLACE);
+ }
+
+ void GL_SelectTexture(int texture /* GLenum */) {
+ int tmu;
+
+ tmu = (texture == GL_TEXTURE0) ? 0 : 1;
+
+ if (tmu == gl_state.currenttmu) {
+ return;
+ }
+
+ gl_state.currenttmu = tmu;
+
+ gl.glActiveTextureARB(texture);
+ gl.glClientActiveTextureARB(texture);
+ }
+
+ int[] lastmodes = { -1, -1 };
+
+ void GL_TexEnv(int mode /* GLenum */
+ ) {
+
+ if (mode != lastmodes[gl_state.currenttmu]) {
+ gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, mode);
+ lastmodes[gl_state.currenttmu] = mode;
+ }
+ }
+
+ void GL_Bind(int texnum) {
+
+ if ((gl_nobind.value != 0) && (draw_chars != null)) {
+ // performance evaluation option
+ texnum = draw_chars.texnum;
+ }
+ if (gl_state.currenttextures[gl_state.currenttmu] == texnum)
+ return;
+
+ gl_state.currenttextures[gl_state.currenttmu] = texnum;
+ gl.glBindTexture(GL.GL_TEXTURE_2D, texnum);
+ }
+
+ void GL_MBind(int target /* GLenum */, int texnum) {
+ GL_SelectTexture(target);
+ if (target == GL_TEXTURE0) {
+ if (gl_state.currenttextures[0] == texnum)
+ return;
+ }
+ else {
+ if (gl_state.currenttextures[1] == texnum)
+ return;
+ }
+ GL_Bind(texnum);
+ }
+
+ // glmode_t
+ static class glmode_t {
+ String name;
+ int minimize, maximize;
+
+ glmode_t(String name, int minimize, int maximze) {
+ this.name = name;
+ this.minimize = minimize;
+ this.maximize = maximze;
+ }
+ }
+
+ static final glmode_t modes[] =
+ {
+ new glmode_t("GL_NEAREST", GL.GL_NEAREST, GL.GL_NEAREST),
+ new glmode_t("GL_LINEAR", GL.GL_LINEAR, GL.GL_LINEAR),
+ new glmode_t("GL_NEAREST_MIPMAP_NEAREST", GL.GL_NEAREST_MIPMAP_NEAREST, GL.GL_NEAREST),
+ new glmode_t("GL_LINEAR_MIPMAP_NEAREST", GL.GL_LINEAR_MIPMAP_NEAREST, GL.GL_LINEAR),
+ new glmode_t("GL_NEAREST_MIPMAP_LINEAR", GL.GL_NEAREST_MIPMAP_LINEAR, GL.GL_NEAREST),
+ new glmode_t("GL_LINEAR_MIPMAP_LINEAR", GL.GL_LINEAR_MIPMAP_LINEAR, GL.GL_LINEAR)};
+
+ static final int NUM_GL_MODES = modes.length;
+
+ // gltmode_t
+ static class gltmode_t {
+ String name;
+ int mode;
+
+ gltmode_t(String name, int mode) {
+ this.name = name;
+ this.mode = mode;
+ }
+ }
+
+ static final gltmode_t[] gl_alpha_modes =
+ {
+ new gltmode_t("default", 4),
+ new gltmode_t("GL_RGBA", GL.GL_RGBA),
+ new gltmode_t("GL_RGBA8", GL.GL_RGBA8),
+ new gltmode_t("GL_RGB5_A1", GL.GL_RGB5_A1),
+ new gltmode_t("GL_RGBA4", GL.GL_RGBA4),
+ new gltmode_t("GL_RGBA2", GL.GL_RGBA2),
+ };
+
+ static final int NUM_GL_ALPHA_MODES = gl_alpha_modes.length;
+
+ static final gltmode_t[] gl_solid_modes =
+ {
+ new gltmode_t("default", 3),
+ new gltmode_t("GL_RGB", GL.GL_RGB),
+ new gltmode_t("GL_RGB8", GL.GL_RGB8),
+ new gltmode_t("GL_RGB5", GL.GL_RGB5),
+ new gltmode_t("GL_RGB4", GL.GL_RGB4),
+ new gltmode_t("GL_R3_G3_B2", GL.GL_R3_G3_B2),
+ // #ifdef GL_RGB2_EXT
+ new gltmode_t("GL_RGB2", GL.GL_RGB2_EXT)
+ // #endif
+ };
+
+ static final int NUM_GL_SOLID_MODES = gl_solid_modes.length;
+
+ /*
+ ===============
+ GL_TextureMode
+ ===============
+ */
+ void GL_TextureMode(String string) {
+
+ int i;
+ for (i = 0; i < NUM_GL_MODES; i++) {
+ if (modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == NUM_GL_MODES) {
+ ri.Con_Printf(Defines.PRINT_ALL, "bad filter name: [" + string + "]\n");
+ return;
+ }
+
+ gl_filter_min = modes[i].minimize;
+ gl_filter_max = modes[i].maximize;
+
+ image_t glt;
+ // change all the existing mipmap texture objects
+ for (i = 0; i < numgltextures; i++) {
+ glt = gltextures[i];
+
+ if (glt.type != it_pic && glt.type != it_sky) {
+ GL_Bind(glt.texnum);
+ gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_min);
+ gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ }
+ }
+ }
+
+ /*
+ ===============
+ GL_TextureAlphaMode
+ ===============
+ */
+ void GL_TextureAlphaMode(String string) {
+
+ int i;
+ for (i = 0; i < NUM_GL_ALPHA_MODES; i++) {
+ if (gl_alpha_modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == NUM_GL_ALPHA_MODES) {
+ ri.Con_Printf(Defines.PRINT_ALL, "bad alpha texture mode name: [" + string + "]\n");
+ return;
+ }
+
+ gl_tex_alpha_format = gl_alpha_modes[i].mode;
+ }
+
+ /*
+ ===============
+ GL_TextureSolidMode
+ ===============
+ */
+ void GL_TextureSolidMode(String string) {
+ int i;
+ for (i = 0; i < NUM_GL_SOLID_MODES; i++) {
+ if (gl_solid_modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == NUM_GL_SOLID_MODES) {
+ ri.Con_Printf(Defines.PRINT_ALL, "bad solid texture mode name: [" + string + "]\n");
+ return;
+ }
+
+ gl_tex_solid_format = gl_solid_modes[i].mode;
+ }
+
+ /*
+ ===============
+ GL_ImageList_f
+ ===============
+ */
+ void GL_ImageList_f() {
+
+ image_t image;
+ int texels;
+ final String[] palstrings = { "RGB", "PAL" };
+
+ ri.Con_Printf(Defines.PRINT_ALL, "------------------\n");
+ texels = 0;
+
+ for (int i = 0; i < numgltextures; i++) {
+ image = gltextures[i];
+ if (image.texnum <= 0)
+ continue;
+
+ texels += image.upload_width * image.upload_height;
+ switch (image.type) {
+ case it_skin :
+ ri.Con_Printf(Defines.PRINT_ALL, "M");
+ break;
+ case it_sprite :
+ ri.Con_Printf(Defines.PRINT_ALL, "S");
+ break;
+ case it_wall :
+ ri.Con_Printf(Defines.PRINT_ALL, "W");
+ break;
+ case it_pic :
+ ri.Con_Printf(Defines.PRINT_ALL, "P");
+ break;
+ default :
+ ri.Con_Printf(Defines.PRINT_ALL, " ");
+ break;
+ }
+
+ ri.Con_Printf(
+ Defines.PRINT_ALL,
+ " %3i %3i %s: %s\n",
+ new Vargs(4).add(image.upload_width).add(image.upload_height).add(palstrings[(image.paletted) ? 1 : 0]).add(
+ image.name));
+ }
+ ri.Con_Printf(Defines.PRINT_ALL, "Total texel count (not counting mipmaps): " + texels + '\n');
+ }
+
+ /*
+ =============================================================================
+
+ scrap allocation
+
+ Allocate all the little status bar objects into a single texture
+ to crutch up inefficient hardware / drivers
+
+ =============================================================================
+ */
+
+ static final int MAX_SCRAPS = 1;
+ static final int BLOCK_WIDTH = 256;
+ static final int BLOCK_HEIGHT = 256;
+
+ int[][] scrap_allocated = new int[MAX_SCRAPS][BLOCK_WIDTH];
+ byte[][] scrap_texels = new byte[MAX_SCRAPS][BLOCK_WIDTH * BLOCK_HEIGHT];
+ boolean scrap_dirty;
+
+ static class pos_t {
+ int x, y;
+
+ pos_t(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+ }
+
+ // returns a texture number and the position inside it
+ int Scrap_AllocBlock(int w, int h, pos_t pos) {
+ int i, j;
+ int best, best2;
+ int texnum;
+
+ for (texnum = 0; texnum < MAX_SCRAPS; texnum++) {
+ best = BLOCK_HEIGHT;
+
+ for (i = 0; i < BLOCK_WIDTH - w; i++) {
+ best2 = 0;
+
+ for (j = 0; j < w; j++) {
+ if (scrap_allocated[texnum][i + j] >= best)
+ break;
+ if (scrap_allocated[texnum][i + j] > best2)
+ best2 = scrap_allocated[texnum][i + j];
+ }
+ if (j == w) { // this is a valid spot
+ pos.x = i;
+ pos.y = best = best2;
+ }
+ }
+
+ if (best + h > BLOCK_HEIGHT)
+ continue;
+
+ for (i = 0; i < w; i++)
+ scrap_allocated[texnum][pos.x + i] = best + h;
+
+ return texnum;
+ }
+
+ return -1;
+ // Sys_Error ("Scrap_AllocBlock: full");
+ }
+
+ int scrap_uploads = 0;
+
+ void Scrap_Upload() {
+ scrap_uploads++;
+ GL_Bind(TEXNUM_SCRAPS);
+ GL_Upload8(scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, false);
+ scrap_dirty = false;
+ }
+
+ /*
+ =================================================================
+
+ PCX LOADING
+
+ =================================================================
+ */
+
+ /*
+ ==============
+ LoadPCX
+ ==============
+ */
+ byte[] LoadPCX(String filename, byte[][] palette, Dimension dim) {
+ qfiles.pcx_t pcx;
+
+ //
+ // load the file
+ //
+ byte[] raw = ri.FS_LoadFile(filename);
+
+ if (raw == null) {
+ ri.Con_Printf(Defines.PRINT_DEVELOPER, "Bad pcx file " + filename + '\n');
+ return null;
+ }
+
+ //
+ // parse the PCX file
+ //
+ pcx = new qfiles.pcx_t(raw);
+
+ if (pcx.manufacturer != 0x0a
+ || pcx.version != 5
+ || pcx.encoding != 1
+ || pcx.bits_per_pixel != 8
+ || pcx.xmax >= 640
+ || pcx.ymax >= 480) {
+
+ ri.Con_Printf(Defines.PRINT_ALL, "Bad pcx file " + filename + '\n');
+ return null;
+ }
+
+ int width = pcx.xmax - pcx.xmin + 1;
+ int height = pcx.ymax - pcx.ymin + 1;
+
+ byte[] pix = new byte[width * height];
+
+ if (palette != null) {
+ palette[0] = new byte[768];
+ System.arraycopy(raw, raw.length - 768, palette[0], 0, 768);
+ }
+
+ if (dim != null) {
+ dim.width = width;
+ dim.height = height;
+ }
+
+ //
+ // decode pcx
+ //
+ int count = 0;
+ byte dataByte = 0;
+ int runLength = 0;
+ int x, y;
+
+ for (y = 0; y < height; y++) {
+ for (x = 0; x < width;) {
+
+ dataByte = pcx.data.get();
+
+ if ((dataByte & 0xC0) == 0xC0) {
+ runLength = dataByte & 0x3F;
+ dataByte = pcx.data.get();
+ // write runLength pixel
+ while (runLength-- > 0) {
+ pix[count++] = dataByte;
+ x++;
+ }
+ }
+ else {
+ // write one pixel
+ pix[count++] = dataByte;
+ x++;
+ }
+ }
+ }
+ return pix;
+ }
+
+ // /*
+ // =========================================================
+ //
+ // TARGA LOADING
+ //
+ // =========================================================
+ // */
+ /*
+ =============
+ LoadTGA
+ =============
+ */
+ byte[] LoadTGA(String name, Dimension dim) {
+ int columns, rows, numPixels;
+ int pixbuf; // index into pic
+ int row, column;
+ byte[] raw;
+ ByteBuffer buf_p;
+ int length;
+ qfiles.tga_t targa_header;
+ byte[] pic = null;
+
+ //
+ // load the file
+ //
+ raw = ri.FS_LoadFile (name);
+
+ if (raw == null)
+ {
+ ri.Con_Printf(Defines.PRINT_DEVELOPER, "Bad tga file "+ name +'\n');
+ return null;
+ }
+
+ targa_header = new qfiles.tga_t(raw);
+
+ if (targa_header.image_type != 2 && targa_header.image_type != 10)
+ ri.Sys_Error(Defines.ERR_DROP, "LoadTGA: Only type 2 and 10 targa RGB images supported\n");
+
+ if (targa_header.colormap_type != 0 || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24))
+ ri.Sys_Error (Defines.ERR_DROP, "LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
+
+ columns = targa_header.width;
+ rows = targa_header.height;
+ numPixels = columns * rows;
+
+ if (dim != null) {
+ dim.width = columns;
+ dim.height = rows;
+ }
+
+ pic = new byte[numPixels * 4]; // targa_rgba;
+
+ if (targa_header.id_length != 0)
+ targa_header.data.position(targa_header.id_length); // skip TARGA image comment
+
+ buf_p = targa_header.data;
+
+ byte red,green,blue,alphabyte;
+ red = green = blue = alphabyte = 0;
+ int packetHeader, packetSize, j;
+
+ if (targa_header.image_type==2) { // Uncompressed, RGB images
+ for(row=rows-1; row>=0; row--) {
+
+ pixbuf = row * columns * 4;
+
+ for(column=0; column<columns; column++) {
+ switch (targa_header.pixel_size) {
+ case 24:
+
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ pic[pixbuf++] = red;
+ pic[pixbuf++] = green;
+ pic[pixbuf++] = blue;
+ pic[pixbuf++] = (byte)255;
+ break;
+ case 32:
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ alphabyte = buf_p.get();
+ pic[pixbuf++] = red;
+ pic[pixbuf++] = green;
+ pic[pixbuf++] = blue;
+ pic[pixbuf++] = alphabyte;
+ break;
+ }
+ }
+ }
+ }
+ else if (targa_header.image_type==10) { // Runlength encoded RGB images
+ for(row=rows-1; row>=0; row--) {
+
+ pixbuf = row * columns * 4;
+ try {
+
+ for(column=0; column<columns; ) {
+
+ packetHeader= buf_p.get() & 0xFF;
+ packetSize = 1 + (packetHeader & 0x7f);
+
+ if ((packetHeader & 0x80) != 0) { // run-length packet
+ switch (targa_header.pixel_size) {
+ case 24:
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ alphabyte = (byte)255;
+ break;
+ case 32:
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ alphabyte = buf_p.get();
+ break;
+ }
+
+ for(j=0;j<packetSize;j++) {
+ pic[pixbuf++]=red;
+ pic[pixbuf++]=green;
+ pic[pixbuf++]=blue;
+ pic[pixbuf++]=alphabyte;
+ column++;
+ if (column==columns) { // run spans across rows
+ column=0;
+ if (row>0)
+ row--;
+ else
+ // goto label breakOut;
+ throw new longjmpException();
+
+ pixbuf = row * columns * 4;
+ }
+ }
+ }
+ else { // non run-length packet
+ for(j=0;j<packetSize;j++) {
+ switch (targa_header.pixel_size) {
+ case 24:
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ pic[pixbuf++] = red;
+ pic[pixbuf++] = green;
+ pic[pixbuf++] = blue;
+ pic[pixbuf++] = (byte)255;
+ break;
+ case 32:
+ blue = buf_p.get();
+ green = buf_p.get();
+ red = buf_p.get();
+ alphabyte = buf_p.get();
+ pic[pixbuf++] = red;
+ pic[pixbuf++] = green;
+ pic[pixbuf++] = blue;
+ pic[pixbuf++] = alphabyte;
+ break;
+ }
+ column++;
+ if (column==columns) { // pixel packet run spans across rows
+ column=0;
+ if (row>0)
+ row--;
+ else
+ // goto label breakOut;
+ throw new longjmpException();
+
+ pixbuf = row * columns * 4;
+ }
+ }
+ }
+ }
+ } catch (longjmpException e){
+ // label breakOut:
+ }
+ }
+ }
+ return pic;
+ }
+
+ /*
+ ====================================================================
+
+ IMAGE FLOOD FILLING
+
+ ====================================================================
+ */
+
+ /*
+ =================
+ Mod_FloodFillSkin
+
+ Fill background pixels so mipmapping doesn't have haloes
+ =================
+ */
+
+ static class floodfill_t {
+ short x, y;
+ }
+
+ // must be a power of 2
+ static final int FLOODFILL_FIFO_SIZE = 0x1000;
+ static final int FLOODFILL_FIFO_MASK = FLOODFILL_FIFO_SIZE - 1;
+ //
+ // #define FLOODFILL_STEP( off, dx, dy ) \
+ // { \
+ // if (pos[off] == fillcolor) \
+ // { \
+ // pos[off] = 255; \
+ // fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \
+ // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
+ // } \
+ // else if (pos[off] != 255) fdc = pos[off]; \
+ // }
+
+ // void FLOODFILL_STEP( int off, int dx, int dy )
+ // {
+ // if (pos[off] == fillcolor)
+ // {
+ // pos[off] = 255;
+ // fifo[inpt].x = x + dx; fifo[inpt].y = y + dy;
+ // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+ // }
+ // else if (pos[off] != 255) fdc = pos[off];
+ // }
+
+ // TODO check this: R_FloodFillSkin( byte[] skin, int skinwidth, int skinheight)
+ void R_FloodFillSkin(byte[] skin, int skinwidth, int skinheight) {
+ // byte fillcolor = *skin; // assume this is the pixel to fill
+ int fillcolor = skin[0] & 0xff;
+ floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE];
+ int inpt = 0, outpt = 0;
+ int filledcolor = -1;
+ int i;
+
+ for (int j = 0; j < fifo.length; j++) {
+ fifo[j] = new floodfill_t();
+ }
+
+ if (filledcolor == -1) {
+ filledcolor = 0;
+ // attempt to find opaque black
+ for (i = 0; i < 256; ++i)
+ // TODO check this
+ if (d_8to24table[i] == 0xFF000000) { // alpha 1.0
+ //if (d_8to24table[i] == (255 << 0)) // alpha 1.0
+ filledcolor = i;
+ break;
+ }
+ }
+
+ // can't fill to filled color or to transparent color (used as visited marker)
+ if ((fillcolor == filledcolor) || (fillcolor == 255)) {
+ return;
+ }
+
+ fifo[inpt].x = 0;
+ fifo[inpt].y = 0;
+ inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+
+ while (outpt != inpt) {
+ int x = fifo[outpt].x;
+ int y = fifo[outpt].y;
+ int fdc = filledcolor;
+ // byte *pos = &skin[x + skinwidth * y];
+ int pos = x + skinwidth * y;
+ //
+ outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;
+
+ int off, dx, dy;
+
+ if (x > 0) {
+ // FLOODFILL_STEP( -1, -1, 0 );
+ off = -1;
+ dx = -1;
+ dy = 0;
+ if (skin[pos + off] == (byte) fillcolor) {
+ skin[pos + off] = (byte) 255;
+ fifo[inpt].x = (short) (x + dx);
+ fifo[inpt].y = (short) (y + dy);
+ inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+ }
+ else if (skin[pos + off] != (byte) 255)
+ fdc = skin[pos + off] & 0xff;
+ }
+
+ if (x < skinwidth - 1) {
+ // FLOODFILL_STEP( 1, 1, 0 );
+ off = 1;
+ dx = 1;
+ dy = 0;
+ if (skin[pos + off] == (byte) fillcolor) {
+ skin[pos + off] = (byte) 255;
+ fifo[inpt].x = (short) (x + dx);
+ fifo[inpt].y = (short) (y + dy);
+ inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+ }
+ else if (skin[pos + off] != (byte) 255)
+ fdc = skin[pos + off] & 0xff;
+ }
+
+ if (y > 0) {
+ // FLOODFILL_STEP( -skinwidth, 0, -1 );
+ off = -skinwidth;
+ dx = 0;
+ dy = -1;
+ if (skin[pos + off] == (byte) fillcolor) {
+ skin[pos + off] = (byte) 255;
+ fifo[inpt].x = (short) (x + dx);
+ fifo[inpt].y = (short) (y + dy);
+ inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+ }
+ else if (skin[pos + off] != (byte) 255)
+ fdc = skin[pos + off] & 0xff;
+ }
+
+ if (y < skinheight - 1) {
+ // FLOODFILL_STEP( skinwidth, 0, 1 );
+ off = skinwidth;
+ dx = 0;
+ dy = 1;
+ if (skin[pos + off] == (byte) fillcolor) {
+ skin[pos + off] = (byte) 255;
+ fifo[inpt].x = (short) (x + dx);
+ fifo[inpt].y = (short) (y + dy);
+ inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
+ }
+ else if (skin[pos + off] != (byte) 255)
+ fdc = skin[pos + off] & 0xff;
+
+ }
+
+ skin[x + skinwidth * y] = (byte) fdc;
+ }
+ }
+
+ // =======================================================
+
+ /*
+ ================
+ GL_ResampleTexture
+ ================
+ */
+ // cwei :-)
+ void GL_ResampleTexture(int[] in, int inwidth, int inheight, int[] out, int outwidth, int outheight) {
+ // int i, j;
+ // unsigned *inrow, *inrow2;
+ // int frac, fracstep;
+ // int[] p1 = new int[1024];
+ // int[] p2 = new int[1024];
+ //
+
+ // *** this source do the same ***
+ BufferedImage image = new BufferedImage(inwidth, inheight, BufferedImage.TYPE_INT_ARGB);
+
+ image.setRGB(0, 0, inwidth, inheight, in, 0, inwidth);
+
+ AffineTransformOp op =
+ new AffineTransformOp(
+ AffineTransform.getScaleInstance(outwidth * 1.0 / inwidth, outheight * 1.0 / inheight),
+ AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+ BufferedImage tmp = op.filter(image, null);
+
+ tmp.getRGB(0, 0, outwidth, outheight, out, 0, outwidth);
+
+ // *** end ***
+
+ // byte *pix1, *pix2, *pix3, *pix4;
+ //
+ // fracstep = inwidth*0x10000/outwidth;
+ //
+ // frac = fracstep>>2;
+ // for (i=0 ; i<outwidth ; i++)
+ // {
+ // p1[i] = 4*(frac>>16);
+ // frac += fracstep;
+ // }
+ // frac = 3*(fracstep>>2);
+ // for (i=0 ; i<outwidth ; i++)
+ // {
+ // p2[i] = 4*(frac>>16);
+ // frac += fracstep;
+ // }
+ //
+ // for (i=0 ; i<outheight ; i++, out += outwidth)
+ // {
+ // inrow = in + inwidth*(int)((i+0.25)*inheight/outheight);
+ // inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight);
+ // frac = fracstep >> 1;
+ // for (j=0 ; j<outwidth ; j++)
+ // {
+ // pix1 = (byte *)inrow + p1[j];
+ // pix2 = (byte *)inrow + p2[j];
+ // pix3 = (byte *)inrow2 + p1[j];
+ // pix4 = (byte *)inrow2 + p2[j];
+ // ((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2;
+ // ((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2;
+ // ((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2;
+ // ((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2;
+ // }
+ // }
+ }
+
+ /*
+ ================
+ GL_LightScaleTexture
+
+ Scale up the pixel values in a texture to increase the
+ lighting range
+ ================
+ */
+ void GL_LightScaleTexture(int[] in, int inwidth, int inheight, boolean only_gamma) {
+ if (only_gamma) {
+ int i, c;
+ int r, g, b, color;
+
+ c = inwidth * inheight;
+ for (i = 0; i < c; i++) {
+ color = in[i];
+ r = (color >> 0) & 0xFF;
+ g = (color >> 8) & 0xFF;
+ b = (color >> 16) & 0xFF;
+
+ r = gammatable[r] & 0xFF;
+ g = gammatable[g] & 0xFF;
+ b = gammatable[b] & 0xFF;
+
+ in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000);
+ }
+ }
+ else {
+ int i, c;
+ int r, g, b, color;
+
+ c = inwidth * inheight;
+ for (i = 0; i < c; i++) {
+ color = in[i];
+ r = (color >> 0) & 0xFF;
+ g = (color >> 8) & 0xFF;
+ b = (color >> 16) & 0xFF;
+
+ r = gammatable[intensitytable[r] & 0xFF] & 0xFF;
+ g = gammatable[intensitytable[g] & 0xFF] & 0xFF;
+ b = gammatable[intensitytable[b] & 0xFF] & 0xFF;
+
+ in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000);
+ }
+
+ }
+ }
+
+ /*
+ ================
+ GL_MipMap
+
+ Operates in place, quartering the size of the texture
+ ================
+ */
+ void GL_MipMap(int[] in, int width, int height) {
+ int i, j;
+ int[] out;
+
+ out = in;
+
+ int inIndex = 0;
+ int outIndex = 0;
+
+ int r, g, b, a;
+ int p1, p2, p3, p4;
+
+ for (i = 0; i < height; i += 2, inIndex += width) {
+ for (j = 0; j < width; j += 2, outIndex += 1, inIndex += 2) {
+
+ p1 = in[inIndex + 0];
+ p2 = in[inIndex + 1];
+ p3 = in[inIndex + width + 0];
+ p4 = in[inIndex + width + 1];
+
+ r = (((p1 >> 0) & 0xFF) + ((p2 >> 0) & 0xFF) + ((p3 >> 0) & 0xFF) + ((p4 >> 0) & 0xFF)) >> 2;
+ g = (((p1 >> 8) & 0xFF) + ((p2 >> 8) & 0xFF) + ((p3 >> 8) & 0xFF) + ((p4 >> 8) & 0xFF)) >> 2;
+ b = (((p1 >> 16) & 0xFF) + ((p2 >> 16) & 0xFF) + ((p3 >> 16) & 0xFF) + ((p4 >> 16) & 0xFF)) >> 2;
+ a = (((p1 >> 24) & 0xFF) + ((p2 >> 24) & 0xFF) + ((p3 >> 24) & 0xFF) + ((p4 >> 24) & 0xFF)) >> 2;
+
+ out[outIndex] = (r << 0) | (g << 8) | (b << 16) | (a << 24);
+ }
+ }
+ }
+
+ /*
+ ===============
+ GL_Upload32
+
+ Returns has_alpha
+ ===============
+ */
+ void GL_BuildPalettedTexture(byte[] paletted_texture, int[] scaled, int scaled_width, int scaled_height) {
+
+ int r, g, b, c;
+ int size = scaled_width * scaled_height;
+
+ for (int i = 0; i < size; i++) {
+
+ r = (scaled[i] >> 3) & 31;
+ g = (scaled[i] >> 10) & 63;
+ b = (scaled[i] >> 19) & 31;
+
+ c = r | (g << 5) | (b << 11);
+
+ paletted_texture[i] = gl_state.d_16to8table[c];
+ }
+ }
+
+ int upload_width, upload_height;
+ boolean uploaded_paletted;
+
+ /*
+ ===============
+ GL_Upload32
+
+ Returns has_alpha
+ ===============
+ */
+ int[] scaled = new int[256 * 256];
+ byte[] paletted_texture = new byte[256 * 256];
+ IntBuffer tex = Lib.newIntBuffer(512 * 256, ByteOrder.LITTLE_ENDIAN);
+
+ boolean GL_Upload32(int[] data, int width, int height, boolean mipmap) {
+ int samples;
+ int scaled_width, scaled_height;
+ int i, c;
+ int comp;
+
+ Arrays.fill(scaled, 0);
+ Arrays.fill(paletted_texture, (byte)0);
+
+ uploaded_paletted = false;
+
+ for (scaled_width = 1; scaled_width < width; scaled_width <<= 1);
+ if (gl_round_down.value > 0.0f && scaled_width > width && mipmap)
+ scaled_width >>= 1;
+ for (scaled_height = 1; scaled_height < height; scaled_height <<= 1);
+ if (gl_round_down.value > 0.0f && scaled_height > height && mipmap)
+ scaled_height >>= 1;
+
+ // let people sample down the world textures for speed
+ if (mipmap) {
+ scaled_width >>= (int) gl_picmip.value;
+ scaled_height >>= (int) gl_picmip.value;
+ }
+
+ // don't ever bother with >256 textures
+ if (scaled_width > 256)
+ scaled_width = 256;
+ if (scaled_height > 256)
+ scaled_height = 256;
+
+ if (scaled_width < 1)
+ scaled_width = 1;
+ if (scaled_height < 1)
+ scaled_height = 1;
+
+ upload_width = scaled_width;
+ upload_height = scaled_height;
+
+ if (scaled_width * scaled_height > 256 * 256)
+ ri.Sys_Error(Defines.ERR_DROP, "GL_Upload32: too big");
+
+ // scan the texture for any non-255 alpha
+ c = width * height;
+ samples = gl_solid_format;
+
+ for (i = 0; i < c; i++) {
+ if ((data[i] & 0xff000000) != 0xff000000) {
+ samples = gl_alpha_format;
+ break;
+ }
+ }
+
+ if (samples == gl_solid_format)
+ comp = gl_tex_solid_format;
+ else if (samples == gl_alpha_format)
+ comp = gl_tex_alpha_format;
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "Unknown number of texture components " + samples + '\n');
+ comp = samples;
+ }
+
+ // simulates a goto
+ try {
+ if (scaled_width == width && scaled_height == height) {
+ if (!mipmap) {
+ if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && samples == gl_solid_format) {
+ uploaded_paletted = true;
+ GL_BuildPalettedTexture(paletted_texture, data, scaled_width, scaled_height);
+ gl.glTexImage2D(
+ GL.GL_TEXTURE_2D,
+ 0,
+ GL_COLOR_INDEX8_EXT,
+ scaled_width,
+ scaled_height,
+ 0,
+ GL.GL_COLOR_INDEX,
+ GL.GL_UNSIGNED_BYTE,
+ paletted_texture);
+ }
+ else {
+ tex.rewind(); tex.put(data);
+ gl.glTexImage2D(
+ GL.GL_TEXTURE_2D,
+ 0,
+ comp,
+ scaled_width,
+ scaled_height,
+ 0,
+ GL.GL_RGBA,
+ GL.GL_UNSIGNED_BYTE,
+ tex);
+ }
+ //goto done;
+ throw new longjmpException();
+ }
+ //memcpy (scaled, data, width*height*4); were bytes
+ System.arraycopy(data, 0, scaled, 0, width * height);
+ }
+ else
+ GL_ResampleTexture(data, width, height, scaled, scaled_width, scaled_height);
+
+ GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap);
+
+ if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && (samples == gl_solid_format)) {
+ uploaded_paletted = true;
+ GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height);
+ gl.glTexImage2D(
+ GL.GL_TEXTURE_2D,
+ 0,
+ GL_COLOR_INDEX8_EXT,
+ scaled_width,
+ scaled_height,
+ 0,
+ GL.GL_COLOR_INDEX,
+ GL.GL_UNSIGNED_BYTE,
+ paletted_texture);
+ }
+ else {
+ tex.rewind(); tex.put(scaled);
+ gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, tex);
+ }
+
+ if (mipmap) {
+ int miplevel;
+ miplevel = 0;
+ while (scaled_width > 1 || scaled_height > 1) {
+ GL_MipMap(scaled, scaled_width, scaled_height);
+ scaled_width >>= 1;
+ scaled_height >>= 1;
+ if (scaled_width < 1)
+ scaled_width = 1;
+ if (scaled_height < 1)
+ scaled_height = 1;
+
+ miplevel++;
+ if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && samples == gl_solid_format) {
+ uploaded_paletted = true;
+ GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height);
+ gl.glTexImage2D(
+ GL.GL_TEXTURE_2D,
+ miplevel,
+ GL_COLOR_INDEX8_EXT,
+ scaled_width,
+ scaled_height,
+ 0,
+ GL.GL_COLOR_INDEX,
+ GL.GL_UNSIGNED_BYTE,
+ paletted_texture);
+ }
+ else {
+ tex.rewind(); tex.put(scaled);
+ gl.glTexImage2D(
+ GL.GL_TEXTURE_2D,
+ miplevel,
+ comp,
+ scaled_width,
+ scaled_height,
+ 0,
+ GL.GL_RGBA,
+ GL.GL_UNSIGNED_BYTE,
+ tex);
+ }
+ }
+ }
+ // label done:
+ }
+ catch (longjmpException e) {
+ ; // replaces label done
+ }
+
+ if (mipmap) {
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_min);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ }
+ else {
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_max);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ }
+
+ return (samples == gl_alpha_format);
+ }
+
+ /*
+ ===============
+ GL_Upload8
+
+ Returns has_alpha
+ ===============
+ */
+
+ int[] trans = new int[512 * 256];
+
+ boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, boolean is_sky) {
+
+ Arrays.fill(trans, 0);
+
+ int s = width * height;
+
+ if (s > trans.length)
+ ri.Sys_Error(Defines.ERR_DROP, "GL_Upload8: too large");
+
+ if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) {
+ gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, height, 0, GL.GL_COLOR_INDEX, GL.GL_UNSIGNED_BYTE, data);
+
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_max);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+
+ // TODO check this
+ return false;
+ }
+ else {
+ int p;
+ int rgb;
+ for (int i = 0; i < s; i++) {
+ p = data[i] & 0xff;
+ trans[i] = d_8to24table[p];
+
+ if (p == 255) { // transparent, so scan around for another color
+ // to avoid alpha fringes
+ // FIXME: do a full flood fill so mips work...
+ if (i > width && (data[i - width] & 0xff) != 255)
+ p = data[i - width] & 0xff;
+ else if (i < s - width && (data[i + width] & 0xff) != 255)
+ p = data[i + width] & 0xff;
+ else if (i > 0 && (data[i - 1] & 0xff) != 255)
+ p = data[i - 1] & 0xff;
+ else if (i < s - 1 && (data[i + 1] & 0xff) != 255)
+ p = data[i + 1] & 0xff;
+ else
+ p = 0;
+ // copy rgb components
+
+ // ((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0];
+ // ((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1];
+ // ((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2];
+
+ trans[i] = d_8to24table[p] & 0x00FFFFFF; // only rgb
+ }
+ }
+
+ return GL_Upload32(trans, width, height, mipmap);
+ }
+ }
+
+ /*
+ ================
+ GL_LoadPic
+
+ This is also used as an entry point for the generated r_notexture
+ ================
+ */
+ image_t GL_LoadPic(String name, byte[] pic, int width, int height, int type, int bits) {
+ image_t image;
+ int i;
+
+ // find a free image_t
+ for (i = 0; i<numgltextures ; i++)
+ {
+ image = gltextures[i];
+ if (image.texnum == 0)
+ break;
+ }
+
+ if (i == numgltextures)
+ {
+ if (numgltextures == MAX_GLTEXTURES)
+ ri.Sys_Error (Defines.ERR_DROP, "MAX_GLTEXTURES");
+
+ numgltextures++;
+ }
+ image = gltextures[i];
+
+ if (name.length() > Defines.MAX_QPATH)
+ ri.Sys_Error(Defines.ERR_DROP, "Draw_LoadPic: \"" + name + "\" is too long");
+
+ image.name = name;
+ image.registration_sequence = registration_sequence;
+
+ image.width = width;
+ image.height = height;
+ image.type = type;
+
+
+ if (type == it_skin && bits == 8)
+ R_FloodFillSkin(pic, width, height);
+
+ // load little pics into the scrap
+ if (image.type == it_pic && bits == 8 && image.width < 64 && image.height < 64) {
+ pos_t pos = new pos_t(0, 0);
+ int j, k;
+
+ int texnum = Scrap_AllocBlock(image.width, image.height, pos);
+
+ if (texnum == -1) {
+ // replace goto nonscrap
+
+ image.scrap = false;
+
+ image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in array
+ GL_Bind(image.texnum);
+
+ if (bits == 8) {
+ image.has_alpha =
+ GL_Upload8(pic, width, height, (image.type != it_pic && image.type != it_sky), image.type == it_sky);
+ }
+ else {
+ int[] tmp = new int[pic.length / 4];
+
+ for (i = 0; i < tmp.length; i++) {
+ tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF;
+ tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00;
+ tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000;
+ tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000;
+ }
+
+ image.has_alpha = GL_Upload32(tmp, width, height, (image.type != it_pic && image.type != it_sky));
+ }
+
+ image.upload_width = upload_width; // after power of 2 and scales
+ image.upload_height = upload_height;
+ image.paletted = uploaded_paletted;
+ image.sl = 0;
+ image.sh = 1;
+ image.tl = 0;
+ image.th = 1;
+
+ return image;
+ }
+
+ scrap_dirty = true;
+
+ // copy the texels into the scrap block
+ k = 0;
+ for (i = 0; i < image.height; i++)
+ for (j = 0; j < image.width; j++, k++)
+ scrap_texels[texnum][(pos.y + i) * BLOCK_WIDTH + pos.x + j] = pic[k];
+
+ image.texnum = TEXNUM_SCRAPS + texnum;
+ image.scrap = true;
+ image.has_alpha = true;
+ image.sl = (pos.x + 0.01f) / (float) BLOCK_WIDTH;
+ image.sh = (pos.x + image.width - 0.01f) / (float) BLOCK_WIDTH;
+ image.tl = (pos.y + 0.01f) / (float) BLOCK_WIDTH;
+ image.th = (pos.y + image.height - 0.01f) / (float) BLOCK_WIDTH;
+
+ }
+ else {
+ // this was label nonscrap
+
+ image.scrap = false;
+
+ image.texnum = TEXNUM_IMAGES + image.getId(); //image pos in array
+ GL_Bind(image.texnum);
+
+ if (bits == 8) {
+ image.has_alpha = GL_Upload8(pic, width, height, (image.type != it_pic && image.type != it_sky), image.type == it_sky);
+ }
+ else {
+ int[] tmp = new int[pic.length / 4];
+
+ for (i = 0; i < tmp.length; i++) {
+ tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF;
+ tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00;
+ tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000;
+ tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000;
+ }
+
+ image.has_alpha = GL_Upload32(tmp, width, height, (image.type != it_pic && image.type != it_sky));
+ }
+ image.upload_width = upload_width; // after power of 2 and scales
+ image.upload_height = upload_height;
+ image.paletted = uploaded_paletted;
+ image.sl = 0;
+ image.sh = 1;
+ image.tl = 0;
+ image.th = 1;
+ }
+ return image;
+ }
+
+ /*
+ ================
+ GL_LoadWal
+ ================
+ */
+ image_t GL_LoadWal(String name) {
+
+ image_t image = null;
+
+ byte[] raw = ri.FS_LoadFile(name);
+ if (raw == null) {
+ ri.Con_Printf(Defines.PRINT_ALL, "GL_FindImage: can't load " + name + '\n');
+ return r_notexture;
+ }
+
+ qfiles.miptex_t mt = new qfiles.miptex_t(raw);
+
+ byte[] pix = new byte[mt.width * mt.height];
+ System.arraycopy(raw, mt.offsets[0], pix, 0, pix.length);
+
+ image = GL_LoadPic(name, pix, mt.width, mt.height, it_wall, 8);
+
+ return image;
+ }
+
+ /*
+ ===============
+ GL_FindImage
+
+ Finds or loads the given image
+ ===============
+ */
+ image_t GL_FindImage(String name, int type) {
+ image_t image = null;
+
+ // TODO loest das grossschreibungs problem
+ name = name.toLowerCase();
+ // bughack for bad strings (fuck \0)
+ int index = name.indexOf('\0');
+ if (index != -1)
+ name = name.substring(0, index);
+
+ if (name == null || name.length() < 5)
+ return null; // ri.Sys_Error (ERR_DROP, "GL_FindImage: NULL name");
+ // ri.Sys_Error (ERR_DROP, "GL_FindImage: bad name: %s", name);
+
+ // look for it
+ for (int i = 0; i < numgltextures; i++)
+ {
+ image = gltextures[i];
+ if (name.equals(image.name))
+ {
+ image.registration_sequence = registration_sequence;
+ return image;
+ }
+ }
+
+ //
+ // load the pic from disk
+ //
+ byte[] pic = null;
+ Dimension dim = new Dimension();
+
+ if (name.endsWith(".pcx")) {
+
+ pic = LoadPCX(name, null, dim);
+ if (pic == null)
+ return null;
+ image = GL_LoadPic(name, pic, dim.width, dim.height, type, 8);
+
+ }
+ else if (name.endsWith(".wal")) {
+
+ image = GL_LoadWal(name);
+
+ }
+ else if (name.endsWith(".tga")) {
+
+ pic = LoadTGA(name, dim);
+
+ if (pic == null)
+ return null;
+
+ image = GL_LoadPic(name, pic, dim.width, dim.height, type, 32);
+
+ }
+ else
+ return null;
+
+ return image;
+ }
+
+ /*
+ ===============
+ R_RegisterSkin
+ ===============
+ */
+ protected image_t R_RegisterSkin(String name) {
+ return GL_FindImage(name, it_skin);
+ }
+
+ /*
+ ================
+ GL_FreeUnusedImages
+
+ Any image that was not touched on this registration sequence
+ will be freed.
+ ================
+ */
+ void GL_FreeUnusedImages() {
+
+ // never free r_notexture or particle texture
+ r_notexture.registration_sequence = registration_sequence;
+ r_particletexture.registration_sequence = registration_sequence;
+
+ image_t image = null;
+
+ for (int i = 0; i < numgltextures; i++) {
+ image = gltextures[i];
+ // used this sequence
+ if (image.registration_sequence == registration_sequence)
+ continue;
+ // free image_t slot
+ if (image.registration_sequence == 0)
+ continue;
+ // don't free pics
+ if (image.type == it_pic)
+ continue;
+
+ // free it
+ // TODO jogl bug
+ gl.glDeleteTextures(1, new int[] {image.texnum});
+ image.clear();
+ }
+ }
+
+ /*
+ ===============
+ Draw_GetPalette
+ ===============
+ */
+ protected void Draw_GetPalette() {
+ int r, g, b;
+ Dimension dim;
+ byte[] pic;
+ byte[][] palette = new byte[1][]; //new byte[768];
+
+ // get the palette
+
+ pic = LoadPCX("pics/colormap.pcx", palette, dim = new Dimension());
+
+ if (palette[0] == null || palette[0].length != 768)
+ ri.Sys_Error(Defines.ERR_FATAL, "Couldn't load pics/colormap.pcx");
+
+ byte[] pal = palette[0];
+
+ int j = 0;
+ for (int i = 0; i < 256; i++) {
+ r = pal[j++] & 0xFF;
+ g = pal[j++] & 0xFF;
+ b = pal[j++] & 0xFF;
+
+ d_8to24table[i] = (255 << 24) | (b << 16) | (g << 8) | (r << 0);
+ }
+
+ d_8to24table[255] &= 0x00FFFFFF; // 255 is transparent
+
+ particle_t.setColorPalette(d_8to24table);
+ }
+
+ /*
+ ===============
+ GL_InitImages
+ ===============
+ */
+ void GL_InitImages() {
+ int i, j;
+ float g = vid_gamma.value;
+
+ registration_sequence = 1;
+
+ // init intensity conversions
+ intensity = ri.Cvar_Get("intensity", "2", 0);
+
+ if (intensity.value <= 1)
+ ri.Cvar_Set("intensity", "1");
+
+ gl_state.inverse_intensity = 1 / intensity.value;
+
+ Draw_GetPalette();
+
+ if (qglColorTableEXT) {
+ gl_state.d_16to8table = ri.FS_LoadFile("pics/16to8.dat");
+ if (gl_state.d_16to8table == null)
+ ri.Sys_Error(Defines.ERR_FATAL, "Couldn't load pics/16to8.pcx");
+ }
+
+ if ((gl_config.renderer & (GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2)) != 0) {
+ g = 1.0F;
+ }
+
+ for (i = 0; i < 256; i++) {
+
+ if (g == 1.0f) {
+ gammatable[i] = (byte) i;
+ }
+ else {
+
+ int inf = (int) (255.0f * Math.pow((i + 0.5) / 255.5, g) + 0.5);
+ if (inf < 0)
+ inf = 0;
+ if (inf > 255)
+ inf = 255;
+ gammatable[i] = (byte) inf;
+ }
+ }
+
+ for (i = 0; i < 256; i++) {
+ j = (int) (i * intensity.value);
+ if (j > 255)
+ j = 255;
+ intensitytable[i] = (byte) j;
+ }
+ }
+
+ /*
+ ===============
+ GL_ShutdownImages
+ ===============
+ */
+ void GL_ShutdownImages() {
+ image_t image;
+
+ for (int i=0; i < numgltextures ; i++)
+ {
+ image = gltextures[i];
+
+ if (image.registration_sequence == 0)
+ continue; // free image_t slot
+ // free it
+ // TODO jogl bug
+ gl.glDeleteTextures(1, new int[] {image.texnum});
+ image.clear();
+ }
+ }
+
+}
diff --git a/src/jake2/render/fastjogl/Impl.java b/src/jake2/render/fastjogl/Impl.java
new file mode 100644
index 0000000..03af496
--- /dev/null
+++ b/src/jake2/render/fastjogl/Impl.java
@@ -0,0 +1,343 @@
+/*
+ * Impl.java
+ * Copyright (C) 2003
+ *
+ * $Id: Impl.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.qcommon.Com;
+import jake2.qcommon.xcommand_t;
+import jake2.sys.KBD;
+
+import java.awt.*;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JFrame;
+
+import net.java.games.jogl.*;
+
+/**
+ * Impl
+ *
+ * @author cwei
+ */
+public class Impl extends Misc implements GLEventListener {
+
+ public static final String DRIVER_NAME = "fastjogl";
+
+ // handles the post initialization with JoglRenderer
+ protected boolean post_init = false;
+
+ private final xcommand_t INIT_CALLBACK = new xcommand_t() {
+ public void execute() {
+ // only used for the first run (initialization)
+ // clear the screen
+ gl.glClearColor(0, 0, 0, 0);
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+
+ //
+ // check the post init process
+ //
+ if (!post_init) {
+ ri.Con_Printf(Defines.PRINT_ALL, "Missing multi-texturing for FastJOGL renderer\n");
+ }
+
+ GLimp_EndFrame();
+ }
+ };
+
+ private xcommand_t callback = INIT_CALLBACK;
+ protected boolean contextInUse = false;
+
+ private GraphicsDevice device;
+ private DisplayMode oldDisplayMode;
+
+ GLCanvas canvas;
+ JFrame window;
+
+ // window position on the screen
+ int window_xpos, window_ypos;
+
+ /**
+ * @return true
+ */
+ boolean GLimp_Init(int xpos, int ypos) {
+ // do nothing
+ window_xpos = xpos;
+ window_ypos = ypos;
+ return true;
+ }
+
+ /**
+ * @param dim
+ * @param mode
+ * @param fullscreen
+ * @return enum rserr_t
+ */
+ int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen) {
+
+ Dimension newDim = new Dimension();
+
+ ri.Cvar_Get("r_fakeFullscreen", "0", Globals.CVAR_ARCHIVE);
+
+ ri.Con_Printf(Defines.PRINT_ALL, "Initializing OpenGL display\n");
+
+ ri.Con_Printf(Defines.PRINT_ALL, "...setting mode " + mode + ":");
+
+ if (!ri.Vid_GetModeInfo(newDim, mode)) {
+ ri.Con_Printf(Defines.PRINT_ALL, " invalid mode\n");
+ return rserr_invalid_mode;
+ }
+
+ ri.Con_Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height + '\n');
+
+ // destroy the existing window
+ GLimp_Shutdown();
+
+ window = new JFrame("Jake2");
+
+ GLCanvas canvas = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
+
+ // TODO Use debug pipeline
+ //canvas.setGL(new DebugGL(canvas.getGL()));
+
+ canvas.setNoAutoRedrawMode(true);
+ canvas.addGLEventListener(this);
+
+ window.getContentPane().add(canvas);
+
+ canvas.setSize(newDim.width, newDim.height);
+
+ // register event listener
+ window.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ ri.Cmd_ExecuteText(Defines.EXEC_APPEND, "quit");
+ }
+ });
+
+ // D I F F E R E N T J A K E 2 E V E N T P R O C E S S I N G
+ window.addComponentListener(KBD.listener);
+ canvas.addKeyListener(KBD.listener);
+ canvas.addMouseListener(KBD.listener);
+ canvas.addMouseMotionListener(KBD.listener);
+
+ /*
+ * fullscreen handling
+ */
+ GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
+ device = env.getDefaultScreenDevice();
+
+ if (fullscreen && !device.isFullScreenSupported()) {
+ ri.Con_Printf(Defines.PRINT_ALL, "...fullscreen not supported\n");
+ vid_fullscreen.value = 0;
+ vid_fullscreen.modified = false;
+ }
+
+ fullscreen = fullscreen && device.isFullScreenSupported();
+
+ if (oldDisplayMode == null) {
+ oldDisplayMode = device.getDisplayMode();
+ }
+
+ if (fullscreen) {
+
+ DisplayMode displayMode = findDisplayMode(newDim, oldDisplayMode.getBitDepth(), oldDisplayMode.getRefreshRate());
+
+ if (displayMode != null) {
+ newDim.width = displayMode.getWidth();
+ newDim.height = displayMode.getHeight();
+ window.setUndecorated(true);
+ window.setResizable(false);
+ device.setFullScreenWindow(window);
+ device.setDisplayMode(displayMode);
+ window.setLocation(0, 0);
+ window.setSize(displayMode.getWidth(), displayMode.getHeight());
+ canvas.setSize(displayMode.getWidth(), displayMode.getHeight());
+ ri.Con_Printf(Defines.PRINT_ALL, "...setting fullscreen " + getModeString(displayMode) + '\n');
+ }
+ } else {
+ window.setLocation(window_xpos, window_ypos);
+ window.pack();
+ window.setResizable(false);
+ window.setVisible(true);
+ }
+
+ while (!canvas.isDisplayable()) {
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {}
+ }
+ canvas.requestFocus();
+
+ this.canvas = canvas;
+
+ vid.width = newDim.width;
+ vid.height = newDim.height;
+
+ // let the sound and input subsystems know about the new window
+ ri.Vid_NewWindow(vid.width, vid.height);
+
+ return rserr_ok;
+ }
+
+ DisplayMode findDisplayMode(Dimension dim, int depth, int rate) {
+ DisplayMode mode = null;
+ DisplayMode m = null;
+ DisplayMode[] modes = device.getDisplayModes();
+ 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 && m.getBitDepth() == depth && m.getRefreshRate() == rate) {
+ mode = m;
+ break;
+ }
+ }
+ if (mode == null) mode = oldDisplayMode;
+ Com.Printf(getModeString(mode) + '\n');
+ 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.getBitDepth());
+ sb.append('@');
+ sb.append(m.getRefreshRate());
+ sb.append("Hz");
+ return sb.toString();
+ }
+
+ void GLimp_BeginFrame(float camera_separation) {
+ // do nothing
+ }
+
+ protected void GLimp_EndFrame() {
+ gl.glFlush();
+ // swap buffer
+ // but jogl has no method to swap
+ }
+
+ protected void GLimp_AppActivate(boolean activate) {
+ // do nothing
+ }
+
+ boolean QGL_Init(String dll_name) {
+ // doesn't need libGL.so or .dll loading
+ return true;
+ }
+
+ void QGL_Shutdown() {
+ // doesn't need libGL.so or .dll loading
+ // do nothing
+ }
+
+ void GLimp_Shutdown() {
+ if (oldDisplayMode != null && device.getFullScreenWindow() != null) {
+ try {
+ device.setDisplayMode(oldDisplayMode);
+ device.setFullScreenWindow(null);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ if (this.window != null) {
+ window.dispose();
+ }
+ post_init = false;
+ callback = INIT_CALLBACK;
+ }
+
+ void GLimp_EnableLogging(boolean enable) {
+ // doesn't need jogl logging
+ // do nothing
+ }
+
+ void GLimp_LogNewFrame() {
+ // doesn't need jogl logging
+ // do nothing
+ }
+
+
+
+ // ============================================================================
+ // GLEventListener interface
+ // ============================================================================
+
+ /*
+ * @see net.java.games.jogl.GLEventListener#init(net.java.games.jogl.GLDrawable)
+ */
+ public void init(GLDrawable drawable) {
+ this.gl = drawable.getGL();
+ this.glu = drawable.getGLU();
+
+ // this is a hack to run R_init() in gl context
+ post_init = R_Init2();
+ }
+
+ /*
+ * @see net.java.games.jogl.GLEventListener#display(net.java.games.jogl.GLDrawable)
+ */
+ public void display(GLDrawable drawable) {
+ this.gl = drawable.getGL();
+ this.glu = drawable.getGLU();
+
+ contextInUse = true;
+ callback.execute();
+ contextInUse = false;
+ }
+
+ /*
+ * @see net.java.games.jogl.GLEventListener#displayChanged(net.java.games.jogl.GLDrawable, boolean, boolean)
+ */
+ public void displayChanged(GLDrawable drawable, boolean arg1, boolean arg2) {
+ // do nothing
+ }
+
+ /*
+ * @see net.java.games.jogl.GLEventListener#reshape(net.java.games.jogl.GLDrawable, int, int, int, int)
+ */
+ public void reshape(GLDrawable drawable, int x, int y, int width, int height) {
+ // do nothing
+ }
+
+ /*
+ * @see jake2.client.refexport_t#updateScreen()
+ */
+ public void updateScreen() {
+ this.callback = INIT_CALLBACK;
+ canvas.display();
+ }
+
+ public void updateScreen(xcommand_t callback) {
+ this.callback = callback;
+ canvas.display();
+ }
+} \ No newline at end of file
diff --git a/src/jake2/render/fastjogl/Light.java b/src/jake2/render/fastjogl/Light.java
new file mode 100644
index 0000000..b963b21
--- /dev/null
+++ b/src/jake2/render/fastjogl/Light.java
@@ -0,0 +1,778 @@
+/*
+ * Light.java
+ * Copyright (C) 2003
+ *
+ * $Id: Light.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.client.dlight_t;
+import jake2.client.lightstyle_t;
+import jake2.game.GameBase;
+import jake2.game.cplane_t;
+import jake2.qcommon.longjmpException;
+import jake2.render.*;
+import jake2.util.Math3D;
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.util.Arrays;
+
+import net.java.games.jogl.GL;
+
+/**
+ * Light
+ *
+ * @author cwei
+ */
+public abstract class Light extends Warp {
+ // r_light.c
+
+ int r_dlightframecount;
+
+ static final int DLIGHT_CUTOFF = 64;
+
+ /*
+ =============================================================================
+
+ DYNAMIC LIGHTS BLEND RENDERING
+
+ =============================================================================
+ */
+
+ void R_RenderDlight (dlight_t light)
+ {
+ int i, j;
+ float a;
+ float[] v = {0, 0, 0};
+ float rad;
+
+ rad = light.intensity * 0.35f;
+
+ Math3D.VectorSubtract (light.origin, r_origin, v);
+
+ gl.glBegin (GL.GL_TRIANGLE_FAN);
+ gl.glColor3f (light.color[0]*0.2f, light.color[1]*0.2f, light.color[2]*0.2f);
+ for (i=0 ; i<3 ; i++)
+ v[i] = light.origin[i] - vpn[i]*rad;
+ gl.glVertex3f(v[0], v[1], v[2]);
+ gl.glColor3f (0,0,0);
+ for (i=16 ; i>=0 ; i--)
+ {
+ a = (float)(i/16.0f * Math.PI*2);
+ for (j=0 ; j<3 ; j++)
+ v[j] = (float)(light.origin[j] + vright[j]*Math.cos(a)*rad
+ + vup[j]*Math.sin(a)*rad);
+ gl.glVertex3f(v[0], v[1], v[2]);
+ }
+ gl.glEnd ();
+ }
+
+ /*
+ =============
+ R_RenderDlights
+ =============
+ */
+ void R_RenderDlights()
+ {
+ if (gl_flashblend.value == 0)
+ return;
+
+ r_dlightframecount = r_framecount + 1; // because the count hasn't
+ // advanced yet for this frame
+ gl.glDepthMask(false);
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ gl.glShadeModel (GL.GL_SMOOTH);
+ gl.glEnable (GL.GL_BLEND);
+ gl.glBlendFunc (GL.GL_ONE, GL.GL_ONE);
+
+ for (int i=0 ; i<r_newrefdef.num_dlights ; i++)
+ {
+ R_RenderDlight(r_newrefdef.dlights[i]);
+ }
+
+ gl.glColor3f (1,1,1);
+ gl.glDisable(GL.GL_BLEND);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
+ gl.glDepthMask(true);
+ }
+
+
+ /*
+ =============================================================================
+
+ DYNAMIC LIGHTS
+
+ =============================================================================
+ */
+
+ /*
+ =============
+ R_MarkLights
+ =============
+ */
+ void R_MarkLights (dlight_t light, int bit, mnode_t node)
+ {
+ cplane_t splitplane;
+ float dist;
+ msurface_t surf;
+ int i;
+ int sidebit;
+
+ if (node.contents != -1)
+ return;
+
+ splitplane = node.plane;
+ dist = Math3D.DotProduct (light.origin, splitplane.normal) - splitplane.dist;
+
+ if (dist > light.intensity - DLIGHT_CUTOFF)
+ {
+ R_MarkLights (light, bit, node.children[0]);
+ return;
+ }
+ if (dist < -light.intensity + DLIGHT_CUTOFF)
+ {
+ R_MarkLights (light, bit, node.children[1]);
+ return;
+ }
+
+ // mark the polygons
+ for (i=0 ; i<node.numsurfaces ; i++)
+ {
+
+ surf = r_worldmodel.surfaces[node.firstsurface + i];
+
+ /*
+ * cwei
+ * bugfix for dlight behind the walls
+ */
+ dist = Math3D.DotProduct (light.origin, surf.plane.normal) - surf.plane.dist;
+ sidebit = (dist >= 0) ? 0 : Defines.SURF_PLANEBACK;
+ if ( (surf.flags & Defines.SURF_PLANEBACK) != sidebit )
+ continue;
+ /*
+ * cwei
+ * bugfix end
+ */
+
+ if (surf.dlightframe != r_dlightframecount)
+ {
+ surf.dlightbits = 0;
+ surf.dlightframe = r_dlightframecount;
+ }
+ surf.dlightbits |= bit;
+ }
+
+ R_MarkLights (light, bit, node.children[0]);
+ R_MarkLights (light, bit, node.children[1]);
+ }
+
+
+ /*
+ =============
+ R_PushDlights
+ =============
+ */
+ void R_PushDlights()
+ {
+ int i;
+ dlight_t l;
+
+ if (gl_flashblend.value != 0)
+ return;
+
+ r_dlightframecount = r_framecount + 1; // because the count hasn't
+ // advanced yet for this frame
+ for (i=0 ; i<r_newrefdef.num_dlights ; i++) {
+ l = r_newrefdef.dlights[i];
+ R_MarkLights( l, 1<<i, r_worldmodel.nodes[0] );
+ }
+ }
+
+
+ /*
+ =============================================================================
+
+ LIGHT SAMPLING
+
+ =============================================================================
+ */
+
+ float[] pointcolor = {0, 0, 0}; // vec3_t
+ cplane_t lightplane; // used as shadow plane
+ float[] lightspot = {0, 0, 0}; // vec3_t
+
+ int RecursiveLightPoint (mnode_t node, float[] start, float[] end)
+ {
+ float front, back, frac;
+ boolean side;
+ int sideIndex;
+ cplane_t plane;
+ float[] mid = {0, 0, 0};
+ msurface_t surf;
+ int s, t, ds, dt;
+ int i;
+ mtexinfo_t tex;
+ ByteBuffer lightmap;
+ int maps;
+ int r;
+
+ if (node.contents != -1)
+ return -1; // didn't hit anything
+
+ // calculate mid point
+
+ // FIXME: optimize for axial
+ plane = node.plane;
+ front = Math3D.DotProduct (start, plane.normal) - plane.dist;
+ back = Math3D.DotProduct (end, plane.normal) - plane.dist;
+ side = (front < 0);
+ sideIndex = (side) ? 1 : 0;
+
+ if ( (back < 0) == side)
+ return RecursiveLightPoint (node.children[sideIndex], start, end);
+
+ frac = front / (front-back);
+ mid[0] = start[0] + (end[0] - start[0])*frac;
+ mid[1] = start[1] + (end[1] - start[1])*frac;
+ mid[2] = start[2] + (end[2] - start[2])*frac;
+
+ // go down front side
+ r = RecursiveLightPoint (node.children[sideIndex], start, mid);
+ if (r >= 0)
+ return r; // hit something
+
+ if ( (back < 0) == side )
+ return -1; // didn't hit anuthing
+
+ // check for impact on this node
+ Math3D.VectorCopy (mid, lightspot);
+ lightplane = plane;
+
+ int surfIndex = node.firstsurface;
+ for (i=0 ; i<node.numsurfaces ; i++, surfIndex++)
+ {
+ surf = r_worldmodel.surfaces[surfIndex];
+
+ if ((surf.flags & (Defines.SURF_DRAWTURB | Defines.SURF_DRAWSKY)) != 0)
+ continue; // no lightmaps
+
+ tex = surf.texinfo;
+
+ s = (int)(Math3D.DotProduct (mid, tex.vecs[0]) + tex.vecs[0][3]);
+ t = (int)(Math3D.DotProduct (mid, tex.vecs[1]) + tex.vecs[1][3]);
+
+ if (s < surf.texturemins[0] || t < surf.texturemins[1])
+ continue;
+
+ ds = s - surf.texturemins[0];
+ dt = t - surf.texturemins[1];
+
+ if ( ds > surf.extents[0] || dt > surf.extents[1] )
+ continue;
+
+ if (surf.samples == null)
+ return 0;
+
+ ds >>= 4;
+ dt >>= 4;
+
+ lightmap = surf.samples;
+ int lightmapIndex = 0;
+
+ Math3D.VectorCopy (Globals.vec3_origin, pointcolor);
+ if (lightmap != null)
+ {
+ float[] scale = {0, 0, 0};
+ float[] rgb;
+ lightmapIndex += 3 * (dt * ((surf.extents[0] >> 4) + 1) + ds);
+
+ for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255; maps++)
+ {
+ rgb = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb;
+ scale[0] = gl_modulate.value * rgb[0];
+ scale[1] = gl_modulate.value * rgb[1];
+ scale[2] = gl_modulate.value * rgb[2];
+
+ pointcolor[0] += (lightmap.get(lightmapIndex + 0) & 0xFF) * scale[0] * (1.0f/255);
+ pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF) * scale[1] * (1.0f/255);
+ pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF) * scale[2] * (1.0f/255);
+ lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1) * ((surf.extents[1] >> 4) + 1);
+ }
+ }
+ return 1;
+ }
+
+ // go down back side
+ return RecursiveLightPoint (node.children[1 - sideIndex], mid, end);
+ }
+
+ /*
+ ===============
+ R_LightPoint
+ ===============
+ */
+ void R_LightPoint (float[] p, float[] color)
+ {
+ assert (p.length == 3) : "vec3_t bug";
+ assert (color.length == 3) : "rgb bug";
+
+ float[] end = {0, 0, 0};
+ float r;
+ int lnum;
+ dlight_t dl;
+ float light;
+ float[] dist = {0, 0, 0};
+ float add;
+
+ if (r_worldmodel.lightdata == null)
+ {
+ color[0] = color[1] = color[2] = 1.0f;
+ return;
+ }
+
+ end[0] = p[0];
+ end[1] = p[1];
+ end[2] = p[2] - 2048;
+
+ r = RecursiveLightPoint(r_worldmodel.nodes[0], p, end);
+
+ if (r == -1)
+ {
+ Math3D.VectorCopy (GameBase.vec3_origin, color);
+ }
+ else
+ {
+ Math3D.VectorCopy (pointcolor, color);
+ }
+
+ //
+ // add dynamic lights
+ //
+ light = 0;
+ for (lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++)
+ {
+ dl = r_newrefdef.dlights[lnum];
+
+ Math3D.VectorSubtract (currententity.origin, dl.origin, dist);
+ add = dl.intensity - Math3D.VectorLength(dist);
+ add *= (1.0f/256);
+ if (add > 0)
+ {
+ Math3D.VectorMA (color, add, dl.color, color);
+ }
+ }
+
+ Math3D.VectorScale (color, gl_modulate.value, color);
+ }
+
+
+// ===================================================================
+
+ float[] s_blocklights = new float[34 * 34 * 3];
+
+ /*
+ ===============
+ R_AddDynamicLights
+ ===============
+ */
+ void R_AddDynamicLights(msurface_t surf)
+ {
+ int lnum;
+ int sd, td;
+ float fdist, frad, fminlight;
+ float[] impact = {0, 0, 0};
+ float[] local = {0, 0, 0};
+ int s, t;
+ int i;
+ int smax, tmax;
+ mtexinfo_t tex;
+ dlight_t dl;
+ float[] pfBL;
+ float fsacc, ftacc;
+
+ smax = (surf.extents[0]>>4)+1;
+ tmax = (surf.extents[1]>>4)+1;
+ tex = surf.texinfo;
+
+ for (lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++)
+ {
+ if ( (surf.dlightbits & (1<<lnum)) == 0 )
+ continue; // not lit by this light
+
+ dl = r_newrefdef.dlights[lnum];
+ frad = dl.intensity;
+ fdist = Math3D.DotProduct (dl.origin, surf.plane.normal) -
+ surf.plane.dist;
+ frad -= Math.abs(fdist);
+ // rad is now the highest intensity on the plane
+
+ fminlight = DLIGHT_CUTOFF; // FIXME: make configurable?
+ if (frad < fminlight)
+ continue;
+ fminlight = frad - fminlight;
+
+ for (i=0 ; i<3 ; i++)
+ {
+ impact[i] = dl.origin[i] -
+ surf.plane.normal[i]*fdist;
+ }
+
+ local[0] = Math3D.DotProduct (impact, tex.vecs[0]) + tex.vecs[0][3] - surf.texturemins[0];
+ local[1] = Math3D.DotProduct (impact, tex.vecs[1]) + tex.vecs[1][3] - surf.texturemins[1];
+
+ pfBL = s_blocklights;
+ int pfBLindex = 0;
+ for (t = 0, ftacc = 0 ; t<tmax ; t++, ftacc += 16)
+ {
+ td = (int)(local[1] - ftacc);
+ if ( td < 0 )
+ td = -td;
+
+ for ( s=0, fsacc = 0 ; s<smax ; s++, fsacc += 16, pfBLindex += 3)
+ {
+ sd = (int)( local[0] - fsacc );
+
+ if ( sd < 0 )
+ sd = -sd;
+
+ if (sd > td)
+ fdist = sd + (td>>1);
+ else
+ fdist = td + (sd>>1);
+
+ if ( fdist < fminlight )
+ {
+ pfBL[pfBLindex + 0] += ( frad - fdist ) * dl.color[0];
+ pfBL[pfBLindex + 1] += ( frad - fdist ) * dl.color[1];
+ pfBL[pfBLindex + 2] += ( frad - fdist ) * dl.color[2];
+ }
+ }
+ }
+ }
+ }
+
+
+ /*
+ ** R_SetCacheState
+ */
+ void R_SetCacheState( msurface_t surf )
+ {
+ int maps;
+
+ for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255 ;
+ maps++)
+ {
+ surf.cached_light[maps] = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].white;
+ }
+ }
+
+ /*
+ ===============
+ R_BuildLightMap
+
+ Combine and scale multiple lightmaps into the floating format in blocklights
+ ===============
+ */
+ void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride)
+ {
+ int smax, tmax;
+ int r, g, b, a, max;
+ int i, j, size;
+ ByteBuffer lightmap;
+ float[] scale = {0, 0, 0, 0};
+ int nummaps;
+ float[] bl;
+ lightstyle_t style;
+ int monolightmap;
+
+ if ( (surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP)) != 0 )
+ ri.Sys_Error(Defines.ERR_DROP, "R_BuildLightMap called for non-lit surface");
+
+ smax = (surf.extents[0] >> 4) + 1;
+ tmax = (surf.extents[1] >> 4) + 1;
+ size = smax * tmax;
+ if (size > ((s_blocklights.length * Defines.SIZE_OF_FLOAT) >> 4) )
+ ri.Sys_Error(Defines.ERR_DROP, "Bad s_blocklights size");
+
+ try {
+ // set to full bright if no light data
+ if (surf.samples == null)
+ {
+ int maps;
+
+ for (i=0 ; i<size*3 ; i++)
+ s_blocklights[i] = 255;
+
+ for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255; maps++)
+ {
+ style = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF];
+ }
+ // goto store;
+ throw new longjmpException();
+ }
+
+ // count the # of maps
+ for ( nummaps = 0 ; nummaps < Defines.MAXLIGHTMAPS && surf.styles[nummaps] != (byte)255 ;
+ nummaps++)
+ ;
+
+ lightmap = surf.samples;
+ int lightmapIndex = 0;
+
+ // add all the lightmaps
+ if ( nummaps == 1 )
+ {
+ int maps;
+
+ for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255 ;
+ maps++)
+ {
+ bl = s_blocklights;
+ int blp = 0;
+
+ for (i=0 ; i<3 ; i++)
+ scale[i] = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i];
+
+ if ( scale[0] == 1.0F &&
+ scale[1] == 1.0F &&
+ scale[2] == 1.0F )
+ {
+ for (i=0 ; i<size ; i++)
+ {
+ bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF;
+ bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF;
+ bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF;
+ }
+ }
+ else
+ {
+ for (i=0 ; i<size ; i++)
+ {
+ bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale[0];
+ bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale[1];
+ bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale[2];
+ }
+ }
+ //lightmap += size*3; // skip to next lightmap
+ }
+ }
+ else
+ {
+ int maps;
+
+ // memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size * 3 );
+
+ Arrays.fill(s_blocklights, 0, size * 3, 0.0f);
+
+ for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255 ;
+ maps++)
+ {
+ bl = s_blocklights;
+ int blp = 0;
+
+ for (i=0 ; i<3 ; i++)
+ scale[i] = gl_modulate.value*r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i];
+
+ if ( scale[0] == 1.0F &&
+ scale[1] == 1.0F &&
+ scale[2] == 1.0F )
+ {
+ for (i=0 ; i<size ; i++)
+ {
+ bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF;
+ bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF;
+ bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF;
+ }
+ }
+ else
+ {
+ for (i=0 ; i<size ; i++)
+ {
+ bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale[0];
+ bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale[1];
+ bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale[2];
+ }
+ }
+ //lightmap += size*3; // skip to next lightmap
+ }
+ }
+
+ // add all the dynamic lights
+ if (surf.dlightframe == r_framecount)
+ R_AddDynamicLights(surf);
+
+ // label store:
+ } catch (longjmpException store) {}
+
+ // put into texture format
+ stride -= smax;
+ bl = s_blocklights;
+ int blp = 0;
+
+ monolightmap = gl_monolightmap.string.charAt(0);
+
+ int destp = 0;
+
+ if ( monolightmap == '0' )
+ {
+ for (i=0 ; i<tmax ; i++, destp += stride)
+ {
+ //dest.position(destp);
+
+ for (j=0 ; j<smax ; j++)
+ {
+
+ r = (int)bl[blp++];
+ g = (int)bl[blp++];
+ b = (int)bl[blp++];
+
+ // catch negative lights
+ if (r < 0)
+ r = 0;
+ if (g < 0)
+ g = 0;
+ if (b < 0)
+ b = 0;
+
+ /*
+ ** determine the brightest of the three color components
+ */
+ if (r > g)
+ max = r;
+ else
+ max = g;
+ if (b > max)
+ max = b;
+
+ /*
+ ** alpha is ONLY used for the mono lightmap case. For this reason
+ ** we set it to the brightest of the color components so that
+ ** things don't get too dim.
+ */
+ a = max;
+
+ /*
+ ** rescale all the color components if the intensity of the greatest
+ ** channel exceeds 1.0
+ */
+ if (max > 255)
+ {
+ float t = 255.0F / max;
+
+ r = (int)(r*t);
+ g = (int)(g*t);
+ b = (int)(b*t);
+ a = (int)(a*t);
+ }
+ r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF;
+ dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | (r << 0));
+ }
+ }
+ }
+ else
+ {
+ for (i=0 ; i<tmax ; i++, destp += stride)
+ {
+ //dest.position(destp);
+
+ for (j=0 ; j<smax ; j++)
+ {
+
+ r = (int) bl[blp++];
+ g = (int) bl[blp++];
+ b = (int) bl[blp++];
+
+ // catch negative lights
+ if (r < 0)
+ r = 0;
+ if (g < 0)
+ g = 0;
+ if (b < 0)
+ b = 0;
+
+ /*
+ ** determine the brightest of the three color components
+ */
+ if (r > g)
+ max = r;
+ else
+ max = g;
+ if (b > max)
+ max = b;
+
+ /*
+ ** alpha is ONLY used for the mono lightmap case. For this reason
+ ** we set it to the brightest of the color components so that
+ ** things don't get too dim.
+ */
+ a = max;
+
+ /*
+ ** rescale all the color components if the intensity of the greatest
+ ** channel exceeds 1.0
+ */
+ if (max > 255)
+ {
+ float t = 255.0F / max;
+
+ r = (int)(r*t);
+ g = (int)(g*t);
+ b = (int)(b*t);
+ a = (int)(a*t);
+ }
+
+ /*
+ ** So if we are doing alpha lightmaps we need to set the R, G, and B
+ ** components to 0 and we need to set alpha to 1-alpha.
+ */
+ switch ( monolightmap )
+ {
+ case 'L':
+ case 'I':
+ r = a;
+ g = b = 0;
+ break;
+ case 'C':
+ // try faking colored lighting
+ a = 255 - ((r+g+b)/3);
+ r *= a/255.0f;
+ g *= a/255.0f;
+ b *= a/255.0f;
+ break;
+ case 'A':
+ default:
+ r = g = b = 0;
+ a = 255 - a;
+ break;
+ }
+ r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF;
+ dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | (r << 0));
+ }
+ }
+ }
+ }
+
+}
diff --git a/src/jake2/render/fastjogl/Main.java b/src/jake2/render/fastjogl/Main.java
new file mode 100644
index 0000000..2363db4
--- /dev/null
+++ b/src/jake2/render/fastjogl/Main.java
@@ -0,0 +1,1592 @@
+/*
+ * Main.java
+ * Copyright (C) 2003
+ *
+ * $Id: Main.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.cplane_t;
+import jake2.game.cvar_t;
+import jake2.qcommon.qfiles;
+import jake2.qcommon.xcommand_t;
+import jake2.render.*;
+import jake2.util.Math3D;
+import jake2.util.Vargs;
+
+import java.awt.Dimension;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import net.java.games.jogl.GL;
+import net.java.games.jogl.GLU;
+import net.java.games.jogl.util.BufferUtils;
+import net.java.games.jogl.util.GLUT;
+
+/**
+ * Main
+ *
+ * @author cwei
+ */
+public abstract class Main extends Base {
+
+ GL gl;
+ GLU glu;
+ GLUT glut = new GLUT();
+
+ public static int[] d_8to24table = new int[256];
+
+ int c_visible_lightmaps;
+ int c_visible_textures;
+
+ int registration_sequence;
+
+ // this a hack for function pointer test
+ // default disabled
+ boolean qglColorTableEXT = false;
+ boolean qglActiveTextureARB = false;
+ boolean qglPointParameterfEXT = false;
+ boolean qglLockArraysEXT = false;
+ boolean qwglSwapIntervalEXT = false;
+
+ // =================
+ // abstract methods
+ // =================
+ protected abstract void Draw_GetPalette();
+
+ abstract void GL_ImageList_f();
+ abstract void GL_ScreenShot_f();
+ abstract void GL_SetTexturePalette(int[] palette);
+ abstract void GL_Strings_f();
+
+ abstract void Mod_Modellist_f();
+ abstract mleaf_t Mod_PointInLeaf(float[] point, model_t model);
+
+ abstract boolean QGL_Init(String dll_name);
+ abstract void QGL_Shutdown();
+ abstract boolean GLimp_Init(int xpos, int ypos);
+ abstract void GLimp_BeginFrame(float camera_separation);
+ abstract int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen);
+ abstract void GLimp_Shutdown();
+ abstract void GLimp_EnableLogging(boolean enable);
+ abstract void GLimp_LogNewFrame();
+
+ abstract void GL_SetDefaultState();
+
+ abstract void GL_InitImages();
+ abstract void Mod_Init(); // Model.java
+ abstract void R_InitParticleTexture(); // MIsc.java
+ abstract void R_DrawAliasModel(entity_t e); // Mesh.java
+ abstract void R_DrawBrushModel(entity_t e); // Surf.java
+ abstract void Draw_InitLocal();
+ abstract void R_LightPoint(float[] p, float[] color);
+ abstract void R_PushDlights();
+ abstract void R_MarkLeaves();
+ abstract void R_DrawWorld();
+ abstract void R_RenderDlights();
+ abstract void R_DrawAlphaSurfaces();
+
+ abstract void Mod_FreeAll();
+
+ abstract void GL_ShutdownImages();
+ abstract void GL_Bind(int texnum);
+ abstract void GL_TexEnv(int mode);
+ abstract void GL_TextureMode(String string);
+ abstract void GL_TextureAlphaMode(String string);
+ abstract void GL_TextureSolidMode(String string);
+ abstract void GL_UpdateSwapInterval();
+
+ /*
+ ====================================================================
+
+ from gl_rmain.c
+
+ ====================================================================
+ */
+
+ // IMPORTED FUNCTIONS
+ protected refimport_t ri = null;
+
+ int GL_TEXTURE0 = GL.GL_TEXTURE0;
+ int GL_TEXTURE1 = GL.GL_TEXTURE1;
+
+ viddef_t vid = new viddef_t();
+
+ model_t r_worldmodel;
+
+ float gldepthmin, gldepthmax;
+
+ glconfig_t gl_config = new glconfig_t();
+ glstate_t gl_state = new glstate_t();
+
+ image_t r_notexture; // use for bad textures
+ image_t r_particletexture; // little dot for particles
+
+ entity_t currententity;
+ model_t currentmodel;
+
+ cplane_t frustum[] = { new cplane_t(), new cplane_t(), new cplane_t(), new cplane_t()};
+
+ int r_visframecount; // bumped when going to a new PVS
+ int r_framecount; // used for dlight push checking
+
+ int c_brush_polys, c_alias_polys;
+
+ float v_blend[] = { 0, 0, 0, 0 }; // final blending color
+
+ //
+ // view origin
+ //
+ float[] vup = { 0, 0, 0 };
+ float[] vpn = { 0, 0, 0 };
+ float[] vright = { 0, 0, 0 };
+ float[] r_origin = { 0, 0, 0 };
+
+ float r_world_matrix[] = new float[16];
+ float r_base_world_matrix[] = new float[16];
+
+ //
+ // screen size info
+ //
+ refdef_t r_newrefdef = new refdef_t();
+
+ int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2;
+
+ cvar_t r_norefresh;
+ cvar_t r_drawentities;
+ cvar_t r_drawworld;
+ cvar_t r_speeds;
+ cvar_t r_fullbright;
+ cvar_t r_novis;
+ cvar_t r_nocull;
+ cvar_t r_lerpmodels;
+ cvar_t r_lefthand;
+
+ cvar_t r_lightlevel;
+ // FIXME: This is a HACK to get the client's light level
+
+ cvar_t gl_nosubimage;
+ cvar_t gl_allow_software;
+
+ cvar_t gl_vertex_arrays;
+
+ cvar_t gl_particle_min_size;
+ cvar_t gl_particle_max_size;
+ cvar_t gl_particle_size;
+ cvar_t gl_particle_att_a;
+ cvar_t gl_particle_att_b;
+ cvar_t gl_particle_att_c;
+
+ cvar_t gl_ext_swapinterval;
+ cvar_t gl_ext_palettedtexture;
+ cvar_t gl_ext_multitexture;
+ cvar_t gl_ext_pointparameters;
+ cvar_t gl_ext_compiled_vertex_array;
+
+ cvar_t gl_log;
+ cvar_t gl_bitdepth;
+ cvar_t gl_drawbuffer;
+ cvar_t gl_driver;
+ cvar_t gl_lightmap;
+ cvar_t gl_shadows;
+ cvar_t gl_mode;
+ cvar_t gl_dynamic;
+ cvar_t gl_monolightmap;
+ cvar_t gl_modulate;
+ cvar_t gl_nobind;
+ cvar_t gl_round_down;
+ cvar_t gl_picmip;
+ cvar_t gl_skymip;
+ cvar_t gl_showtris;
+ cvar_t gl_ztrick;
+ cvar_t gl_finish;
+ cvar_t gl_clear;
+ cvar_t gl_cull;
+ cvar_t gl_polyblend;
+ cvar_t gl_flashblend;
+ cvar_t gl_playermip;
+ cvar_t gl_saturatelighting;
+ cvar_t gl_swapinterval;
+ cvar_t gl_texturemode;
+ cvar_t gl_texturealphamode;
+ cvar_t gl_texturesolidmode;
+ cvar_t gl_lockpvs;
+
+ cvar_t gl_3dlabs_broken;
+
+ cvar_t vid_fullscreen;
+ cvar_t vid_gamma;
+ cvar_t vid_ref;
+
+ // ============================================================================
+ // to port from gl_rmain.c, ...
+ // ============================================================================
+
+ /*
+ =================
+ R_CullBox
+
+ Returns true if the box is completely outside the frustom
+ =================
+ */
+ final boolean R_CullBox(float[] mins, float[] maxs) {
+ assert(mins.length == 3 && maxs.length == 3) : "vec3_t bug";
+
+ if (r_nocull.value != 0)
+ return false;
+
+ for (int i = 0; i < 4; i++) {
+ if (Math3D.BoxOnPlaneSide(mins, maxs, frustum[i]) == 2)
+ return true;
+ }
+ return false;
+ }
+
+ final void R_RotateForEntity(entity_t e) {
+
+ gl.glTranslatef(e.origin[0], e.origin[1], e.origin[2]);
+
+ gl.glRotatef(e.angles[1], 0, 0, 1);
+ gl.glRotatef(-e.angles[0], 0, 1, 0);
+ gl.glRotatef(-e.angles[2], 1, 0, 0);
+ }
+
+ /*
+ =============================================================
+
+ SPRITE MODELS
+
+ =============================================================
+ */
+
+ /*
+ =================
+ R_DrawSpriteModel
+
+ =================
+ */
+ void R_DrawSpriteModel(entity_t e) {
+ float alpha = 1.0F;
+ float[] point = { 0, 0, 0 };
+
+ qfiles.dsprframe_t frame;
+ qfiles.dsprite_t psprite;
+
+ // don't even bother culling, because it's just a single
+ // polygon without a surface cache
+
+ psprite = (qfiles.dsprite_t) currentmodel.extradata;
+
+ e.frame %= psprite.numframes;
+
+ frame = psprite.frames[e.frame];
+
+ if ((e.flags & Defines.RF_TRANSLUCENT) != 0)
+ alpha = e.alpha;
+
+ if (alpha != 1.0F)
+ gl.glEnable(GL.GL_BLEND);
+
+ gl.glColor4f(1, 1, 1, alpha);
+
+ GL_Bind(currentmodel.skins[e.frame].texnum);
+
+ GL_TexEnv(GL.GL_MODULATE);
+
+ if (alpha == 1.0)
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ else
+ gl.glDisable(GL.GL_ALPHA_TEST);
+
+ gl.glBegin(GL.GL_QUADS);
+
+ gl.glTexCoord2f(0, 1);
+ Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
+ Math3D.VectorMA(point, -frame.origin_x, vright, point);
+ gl.glVertex3f(point[0], point[1], point[2]);
+
+ gl.glTexCoord2f(0, 0);
+ Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
+ Math3D.VectorMA(point, -frame.origin_x, vright, point);
+ gl.glVertex3f(point[0], point[1], point[2]);
+
+ gl.glTexCoord2f(1, 0);
+ Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
+ Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
+ gl.glVertex3f(point[0], point[1], point[2]);
+
+ gl.glTexCoord2f(1, 1);
+ Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
+ Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
+ gl.glVertex3f(point[0], point[1], point[2]);
+
+ gl.glEnd();
+
+ gl.glDisable(GL.GL_ALPHA_TEST);
+ GL_TexEnv(GL.GL_REPLACE);
+
+ if (alpha != 1.0F)
+ gl.glDisable(GL.GL_BLEND);
+
+ gl.glColor4f(1, 1, 1, 1);
+ }
+
+ // ==================================================================================
+
+ /*
+ =============
+ R_DrawNullModel
+ =============
+ cwei :-)
+ */
+ void R_DrawNullModel() {
+ float[] shadelight = { 0, 0, 0 };
+
+ if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) {
+ // cwei wollte blau: shadelight[0] = shadelight[1] = shadelight[2] = 1.0F;
+ shadelight[0] = shadelight[1] = shadelight[2] = 0.0F;
+ shadelight[2] = 0.8F;
+ }
+ else {
+ R_LightPoint(currententity.origin, shadelight);
+ }
+
+ gl.glPushMatrix();
+ R_RotateForEntity(currententity);
+
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ gl.glColor3f(shadelight[0], shadelight[1], shadelight[2]);
+
+ // this replaces the TRIANGLE_FAN
+ glut.glutWireCube(gl, 20);
+
+ /*
+ gl.glBegin(GL.GL_TRIANGLE_FAN);
+ gl.glVertex3f(0, 0, -16);
+ int i;
+ for (i=0 ; i<=4 ; i++) {
+ gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f);
+ }
+ gl.glEnd();
+
+ gl.glBegin(GL.GL_TRIANGLE_FAN);
+ gl.glVertex3f (0, 0, 16);
+ for (i=4 ; i>=0 ; i--) {
+ gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f);
+ }
+ gl.glEnd();
+ */
+ gl.glColor3f(1, 1, 1);
+ gl.glPopMatrix();
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ }
+
+ /*
+ =============
+ R_DrawEntitiesOnList
+ =============
+ */
+ void R_DrawEntitiesOnList() {
+ int i;
+
+ if (r_drawentities.value == 0.0f)
+ return;
+
+ // draw non-transparent first
+ for (i = 0; i < r_newrefdef.num_entities; i++) {
+ currententity = r_newrefdef.entities[i];
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0)
+ continue; // solid
+
+ if ((currententity.flags & Defines.RF_BEAM) != 0) {
+ R_DrawBeam(currententity);
+ }
+ else {
+ currentmodel = currententity.model;
+ if (currentmodel == null) {
+ R_DrawNullModel();
+ continue;
+ }
+ switch (currentmodel.type) {
+ case mod_alias :
+ R_DrawAliasModel(currententity);
+ break;
+ case mod_brush :
+ R_DrawBrushModel(currententity);
+ break;
+ case mod_sprite :
+ R_DrawSpriteModel(currententity);
+ break;
+ default :
+ ri.Sys_Error(Defines.ERR_DROP, "Bad modeltype");
+ break;
+ }
+ }
+ }
+ // draw transparent entities
+ // we could sort these if it ever becomes a problem...
+ gl.glDepthMask(false); // no z writes
+ for (i = 0; i < r_newrefdef.num_entities; i++) {
+ currententity = r_newrefdef.entities[i];
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) == 0)
+ continue; // solid
+
+ if ((currententity.flags & Defines.RF_BEAM) != 0) {
+ R_DrawBeam(currententity);
+ }
+ else {
+ currentmodel = currententity.model;
+
+ if (currentmodel == null) {
+ R_DrawNullModel();
+ continue;
+ }
+ switch (currentmodel.type) {
+ case mod_alias :
+ R_DrawAliasModel(currententity);
+ break;
+ case mod_brush :
+ R_DrawBrushModel(currententity);
+ break;
+ case mod_sprite :
+ R_DrawSpriteModel(currententity);
+ break;
+ default :
+ ri.Sys_Error(Defines.ERR_DROP, "Bad modeltype");
+ break;
+ }
+ }
+ }
+ gl.glDepthMask(true); // back to writing
+ }
+
+ /*
+ ** GL_DrawParticles
+ **
+ */
+ void GL_DrawParticles(int num_particles) {
+ float[] up = { 0, 0, 0 };
+ float[] right = { 0, 0, 0 };
+ float scale;
+ int color;
+
+ float origin_x, origin_y, origin_z;
+
+ Math3D.VectorScale(vup, 1.5f, up);
+ Math3D.VectorScale(vright, 1.5f, right);
+
+ GL_Bind(r_particletexture.texnum);
+ gl.glDepthMask(false); // no z buffering
+ gl.glEnable(GL.GL_BLEND);
+ GL_TexEnv(GL.GL_MODULATE);
+
+ gl.glBegin(GL.GL_TRIANGLES);
+
+ FloatBuffer sourceVertices = particle_t.vertexArray;
+ IntBuffer sourceColors = particle_t.colorArray;
+ for (int j = 0, i = 0; i < num_particles; i++) {
+ origin_x = sourceVertices.get(j++);
+ origin_y = sourceVertices.get(j++);
+ origin_z = sourceVertices.get(j++);
+
+ // hack a scale up to keep particles from disapearing
+ scale =
+ (origin_x - r_origin[0]) * vpn[0]
+ + (origin_y - r_origin[1]) * vpn[1]
+ + (origin_z - r_origin[2]) * vpn[2];
+
+ scale = (scale < 20) ? 1 : 1 + scale * 0.004f;
+
+ color = sourceColors.get(i);
+ gl.glColor4ub(
+ (byte)((color >> 0) & 0xFF),
+ (byte)((color >> 8) & 0xFF),
+ (byte)((color >> 16) & 0xFF),
+ (byte)((color >> 24) & 0xFF)
+ );
+ // first vertex
+ gl.glTexCoord2f(0.0625f, 0.0625f);
+ gl.glVertex3f(origin_x, origin_y, origin_z);
+ // second vertex
+ gl.glTexCoord2f(1.0625f, 0.0625f);
+ gl.glVertex3f(origin_x + up[0] * scale, origin_y + up[1] * scale, origin_z + up[2] * scale);
+ // third vertex
+ gl.glTexCoord2f(0.0625f, 1.0625f);
+ gl.glVertex3f(origin_x + right[0] * scale, origin_y + right[1] * scale, origin_z + right[2] * scale);
+ }
+ gl.glEnd();
+
+ gl.glDisable(GL.GL_BLEND);
+ gl.glColor4f(1, 1, 1, 1);
+ gl.glDepthMask(true); // back to normal Z buffering
+ GL_TexEnv(GL.GL_REPLACE);
+ }
+
+ /*
+ ===============
+ R_DrawParticles
+ ===============
+ */
+ void R_DrawParticles() {
+
+ if (gl_ext_pointparameters.value != 0.0f && qglPointParameterfEXT) {
+
+ //gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
+ gl.glVertexPointer(3, GL.GL_FLOAT, 0, particle_t.vertexArray);
+ gl.glEnableClientState(GL.GL_COLOR_ARRAY);
+ gl.glColorPointer(4, GL.GL_UNSIGNED_BYTE, 0, particle_t.colorArray);
+
+ gl.glDepthMask(false);
+ gl.glEnable(GL.GL_BLEND);
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ gl.glPointSize(gl_particle_size.value);
+
+ gl.glDrawArrays(GL.GL_POINTS, 0, r_newrefdef.num_particles);
+
+ gl.glDisableClientState(GL.GL_COLOR_ARRAY);
+ //gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
+
+ gl.glDisable(GL.GL_BLEND);
+ gl.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ gl.glDepthMask(true);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+
+ }
+ else {
+ GL_DrawParticles(r_newrefdef.num_particles);
+ }
+ }
+
+ /*
+ ============
+ R_PolyBlend
+ ============
+ */
+ void R_PolyBlend() {
+ if (gl_polyblend.value == 0.0f)
+ return;
+
+ if (v_blend[3] == 0.0f)
+ return;
+
+ gl.glDisable(GL.GL_ALPHA_TEST);
+ gl.glEnable(GL.GL_BLEND);
+ gl.glDisable(GL.GL_DEPTH_TEST);
+ gl.glDisable(GL.GL_TEXTURE_2D);
+
+ gl.glLoadIdentity();
+
+ // FIXME: get rid of these
+ gl.glRotatef(-90, 1, 0, 0); // put Z going up
+ gl.glRotatef(90, 0, 0, 1); // put Z going up
+
+ gl.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]);
+
+ gl.glBegin(GL.GL_QUADS);
+
+ gl.glVertex3f(10, 100, 100);
+ gl.glVertex3f(10, -100, 100);
+ gl.glVertex3f(10, -100, -100);
+ gl.glVertex3f(10, 100, -100);
+ gl.glEnd();
+
+ gl.glDisable(GL.GL_BLEND);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ gl.glEnable(GL.GL_ALPHA_TEST);
+
+ gl.glColor4f(1, 1, 1, 1);
+ }
+
+ // =======================================================================
+
+ int SignbitsForPlane(cplane_t out) {
+ // for fast box on planeside test
+ int bits = 0;
+ for (int j = 0; j < 3; j++) {
+ if (out.normal[j] < 0)
+ bits |= (1 << j);
+ }
+ return bits;
+ }
+
+ void R_SetFrustum() {
+ // rotate VPN right by FOV_X/2 degrees
+ Math3D.RotatePointAroundVector(frustum[0].normal, vup, vpn, - (90f - r_newrefdef.fov_x / 2f));
+ // rotate VPN left by FOV_X/2 degrees
+ Math3D.RotatePointAroundVector(frustum[1].normal, vup, vpn, 90f - r_newrefdef.fov_x / 2f);
+ // rotate VPN up by FOV_X/2 degrees
+ Math3D.RotatePointAroundVector(frustum[2].normal, vright, vpn, 90f - r_newrefdef.fov_y / 2f);
+ // rotate VPN down by FOV_X/2 degrees
+ Math3D.RotatePointAroundVector(frustum[3].normal, vright, vpn, - (90f - r_newrefdef.fov_y / 2f));
+
+ for (int i = 0; i < 4; i++) {
+ frustum[i].type = Defines.PLANE_ANYZ;
+ frustum[i].dist = Math3D.DotProduct(r_origin, frustum[i].normal);
+ frustum[i].signbits = (byte) SignbitsForPlane(frustum[i]);
+ }
+ }
+
+ // =======================================================================
+
+ /*
+ ===============
+ R_SetupFrame
+ ===============
+ */
+ void R_SetupFrame() {
+ int i;
+ mleaf_t leaf;
+
+ r_framecount++;
+
+ // build the transformation matrix for the given view angles
+ Math3D.VectorCopy(r_newrefdef.vieworg, r_origin);
+
+ Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup);
+
+ // current viewcluster
+ if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) {
+ r_oldviewcluster = r_viewcluster;
+ r_oldviewcluster2 = r_viewcluster2;
+ leaf = Mod_PointInLeaf(r_origin, r_worldmodel);
+ r_viewcluster = r_viewcluster2 = leaf.cluster;
+
+ // check above and below so crossing solid water doesn't draw wrong
+ if (leaf.contents == 0) { // look down a bit
+ float[] temp = { 0, 0, 0 };
+
+ Math3D.VectorCopy(r_origin, temp);
+ temp[2] -= 16;
+ leaf = Mod_PointInLeaf(temp, r_worldmodel);
+ if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2))
+ r_viewcluster2 = leaf.cluster;
+ }
+ else { // look up a bit
+ float[] temp = { 0, 0, 0 };
+
+ Math3D.VectorCopy(r_origin, temp);
+ temp[2] += 16;
+ leaf = Mod_PointInLeaf(temp, r_worldmodel);
+ if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2))
+ r_viewcluster2 = leaf.cluster;
+ }
+ }
+
+ for (i = 0; i < 4; i++)
+ v_blend[i] = r_newrefdef.blend[i];
+
+ c_brush_polys = 0;
+ c_alias_polys = 0;
+
+ // clear out the portion of the screen that the NOWORLDMODEL defines
+ if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) {
+ gl.glEnable(GL.GL_SCISSOR_TEST);
+ gl.glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
+ gl.glScissor(
+ r_newrefdef.x,
+ vid.height - r_newrefdef.height - r_newrefdef.y,
+ r_newrefdef.width,
+ r_newrefdef.height);
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+ gl.glClearColor(1.0f, 0.0f, 0.5f, 0.5f);
+ gl.glDisable(GL.GL_SCISSOR_TEST);
+ }
+ }
+
+ void MYgluPerspective(double fovy, double aspect, double zNear, double zFar) {
+ double xmin, xmax, ymin, ymax;
+
+ ymax = zNear * Math.tan(fovy * Math.PI / 360.0);
+ ymin = -ymax;
+
+ xmin = ymin * aspect;
+ xmax = ymax * aspect;
+
+ xmin += - (2 * gl_state.camera_separation) / zNear;
+ xmax += - (2 * gl_state.camera_separation) / zNear;
+
+ gl.glFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
+ }
+
+ /*
+ =============
+ R_SetupGL
+ =============
+ */
+ void R_SetupGL() {
+ float screenaspect;
+ int x, x2, y2, y, w, h;
+
+ //
+ // set up viewport
+ //
+ x = (int) Math.floor(r_newrefdef.x * vid.width / vid.width);
+ x2 = (int) Math.ceil((r_newrefdef.x + r_newrefdef.width) * vid.width / vid.width);
+ y = (int) Math.floor(vid.height - r_newrefdef.y * vid.height / vid.height);
+ y2 = (int) Math.ceil(vid.height - (r_newrefdef.y + r_newrefdef.height) * vid.height / vid.height);
+
+ w = x2 - x;
+ h = y - y2;
+
+ gl.glViewport(x, y2, w, h);
+
+ //
+ // set up projection matrix
+ //
+ screenaspect = (float) r_newrefdef.width / r_newrefdef.height;
+ gl.glMatrixMode(GL.GL_PROJECTION);
+ gl.glLoadIdentity();
+ MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096);
+
+ gl.glCullFace(GL.GL_FRONT);
+
+ gl.glMatrixMode(GL.GL_MODELVIEW);
+ gl.glLoadIdentity();
+
+ gl.glRotatef(-90, 1, 0, 0); // put Z going up
+ gl.glRotatef(90, 0, 0, 1); // put Z going up
+ gl.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0);
+ gl.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0);
+ gl.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1);
+ gl.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]);
+
+ gl.glGetFloatv(GL.GL_MODELVIEW_MATRIX, r_world_matrix);
+
+ //
+ // set drawing parms
+ //
+ if (gl_cull.value != 0.0f)
+ gl.glEnable(GL.GL_CULL_FACE);
+ else
+ gl.glDisable(GL.GL_CULL_FACE);
+
+ gl.glDisable(GL.GL_BLEND);
+ gl.glDisable(GL.GL_ALPHA_TEST);
+ gl.glEnable(GL.GL_DEPTH_TEST);
+ }
+
+ /*
+ =============
+ R_Clear
+ =============
+ */
+ int trickframe = 0;
+
+ void R_Clear() {
+ if (gl_ztrick.value != 0.0f) {
+
+ if (gl_clear.value != 0.0f) {
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT);
+ }
+
+ trickframe++;
+ if ((trickframe & 1) != 0) {
+ gldepthmin = 0;
+ gldepthmax = 0.49999f;
+ gl.glDepthFunc(GL.GL_LEQUAL);
+ }
+ else {
+ gldepthmin = 1;
+ gldepthmax = 0.5f;
+ gl.glDepthFunc(GL.GL_GEQUAL);
+ }
+ }
+ else {
+ if (gl_clear.value != 0.0f)
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+ else
+ gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
+
+ gldepthmin = 0;
+ gldepthmax = 1;
+ gl.glDepthFunc(GL.GL_LEQUAL);
+ }
+ gl.glDepthRange(gldepthmin, gldepthmax);
+ }
+
+ void R_Flash() {
+ R_PolyBlend();
+ }
+
+ /*
+ ================
+ R_RenderView
+
+ r_newrefdef must be set before the first call
+ ================
+ */
+ void R_RenderView(refdef_t fd) {
+
+ if (r_norefresh.value != 0.0f)
+ return;
+
+ r_newrefdef = fd;
+
+ // included by cwei
+ if (r_newrefdef == null) {
+ ri.Sys_Error(Defines.ERR_DROP, "R_RenderView: refdef_t fd is null");
+ }
+
+ if (r_worldmodel == null && (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0)
+ ri.Sys_Error(Defines.ERR_DROP, "R_RenderView: NULL worldmodel");
+
+ if (r_speeds.value != 0.0f) {
+ c_brush_polys = 0;
+ c_alias_polys = 0;
+ }
+
+ R_PushDlights();
+
+ if (gl_finish.value != 0.0f)
+ gl.glFinish();
+
+ R_SetupFrame();
+
+ R_SetFrustum();
+
+ R_SetupGL();
+
+ R_MarkLeaves(); // done here so we know if we're in water
+
+ R_DrawWorld();
+
+ R_DrawEntitiesOnList();
+
+ R_RenderDlights();
+
+ R_DrawParticles();
+
+ R_DrawAlphaSurfaces();
+
+ R_Flash();
+
+ if (r_speeds.value != 0.0f) {
+ ri.Con_Printf(
+ Defines.PRINT_ALL,
+ "%4i wpoly %4i epoly %i tex %i lmaps\n",
+ new Vargs(4).add(c_brush_polys).add(c_alias_polys).add(c_visible_textures).add(c_visible_lightmaps));
+ }
+ }
+
+ void R_SetGL2D() {
+ // set 2D virtual screen size
+ gl.glViewport(0, 0, vid.width, vid.height);
+ gl.glMatrixMode(GL.GL_PROJECTION);
+ gl.glLoadIdentity();
+ gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999);
+ gl.glMatrixMode(GL.GL_MODELVIEW);
+ gl.glLoadIdentity();
+ gl.glDisable(GL.GL_DEPTH_TEST);
+ gl.glDisable(GL.GL_CULL_FACE);
+ gl.glDisable(GL.GL_BLEND);
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ gl.glColor4f(1, 1, 1, 1);
+ }
+
+ /*
+ ====================
+ R_SetLightLevel
+
+ ====================
+ */
+ void R_SetLightLevel() {
+ float[] shadelight = { 0, 0, 0 };
+
+ if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0)
+ return;
+
+ // save off light value for server to look at (BIG HACK!)
+
+ R_LightPoint(r_newrefdef.vieworg, shadelight);
+
+ // pick the greatest component, which should be the same
+ // as the mono value returned by software
+ if (shadelight[0] > shadelight[1]) {
+ if (shadelight[0] > shadelight[2])
+ r_lightlevel.value = 150 * shadelight[0];
+ else
+ r_lightlevel.value = 150 * shadelight[2];
+ }
+ else {
+ if (shadelight[1] > shadelight[2])
+ r_lightlevel.value = 150 * shadelight[1];
+ else
+ r_lightlevel.value = 150 * shadelight[2];
+ }
+ }
+
+ /*
+ @@@@@@@@@@@@@@@@@@@@@
+ R_RenderFrame
+
+ @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected void R_RenderFrame(refdef_t fd) {
+ R_RenderView(fd);
+ R_SetLightLevel();
+ R_SetGL2D();
+ }
+
+ protected void R_Register() {
+ r_lefthand = ri.Cvar_Get("hand", "0", Globals.CVAR_USERINFO | Globals.CVAR_ARCHIVE);
+ r_norefresh = ri.Cvar_Get("r_norefresh", "0", 0);
+ r_fullbright = ri.Cvar_Get("r_fullbright", "0", 0);
+ r_drawentities = ri.Cvar_Get("r_drawentities", "1", 0);
+ r_drawworld = ri.Cvar_Get("r_drawworld", "1", 0);
+ r_novis = ri.Cvar_Get("r_novis", "0", 0);
+ r_nocull = ri.Cvar_Get("r_nocull", "0", 0);
+ r_lerpmodels = ri.Cvar_Get("r_lerpmodels", "1", 0);
+ r_speeds = ri.Cvar_Get("r_speeds", "0", 0);
+
+ r_lightlevel = ri.Cvar_Get("r_lightlevel", "1", 0);
+
+ gl_nosubimage = ri.Cvar_Get("gl_nosubimage", "0", 0);
+ gl_allow_software = ri.Cvar_Get("gl_allow_software", "0", 0);
+
+ gl_particle_min_size = ri.Cvar_Get("gl_particle_min_size", "2", Globals.CVAR_ARCHIVE);
+ gl_particle_max_size = ri.Cvar_Get("gl_particle_max_size", "40", Globals.CVAR_ARCHIVE);
+ gl_particle_size = ri.Cvar_Get("gl_particle_size", "40", Globals.CVAR_ARCHIVE);
+ gl_particle_att_a = ri.Cvar_Get("gl_particle_att_a", "0.01", Globals.CVAR_ARCHIVE);
+ gl_particle_att_b = ri.Cvar_Get("gl_particle_att_b", "0.0", Globals.CVAR_ARCHIVE);
+ gl_particle_att_c = ri.Cvar_Get("gl_particle_att_c", "0.01", Globals.CVAR_ARCHIVE);
+
+ gl_modulate = ri.Cvar_Get("gl_modulate", "1", Globals.CVAR_ARCHIVE);
+ gl_log = ri.Cvar_Get("gl_log", "0", 0);
+ gl_bitdepth = ri.Cvar_Get("gl_bitdepth", "0", 0);
+ gl_mode = ri.Cvar_Get("gl_mode", "3", Globals.CVAR_ARCHIVE); // 640x480
+ gl_lightmap = ri.Cvar_Get("gl_lightmap", "0", 0);
+ gl_shadows = ri.Cvar_Get("gl_shadows", "0", Globals.CVAR_ARCHIVE);
+ gl_dynamic = ri.Cvar_Get("gl_dynamic", "1", 0);
+ gl_nobind = ri.Cvar_Get("gl_nobind", "0", 0);
+ gl_round_down = ri.Cvar_Get("gl_round_down", "1", 0);
+ gl_picmip = ri.Cvar_Get("gl_picmip", "0", 0);
+ gl_skymip = ri.Cvar_Get("gl_skymip", "0", 0);
+ gl_showtris = ri.Cvar_Get("gl_showtris", "0", 0);
+ gl_ztrick = ri.Cvar_Get("gl_ztrick", "0", 0);
+ gl_finish = ri.Cvar_Get("gl_finish", "0", Globals.CVAR_ARCHIVE);
+ gl_clear = ri.Cvar_Get("gl_clear", "0", 0);
+ gl_cull = ri.Cvar_Get("gl_cull", "1", 0);
+ gl_polyblend = ri.Cvar_Get("gl_polyblend", "1", 0);
+ gl_flashblend = ri.Cvar_Get("gl_flashblend", "0", 0);
+ gl_playermip = ri.Cvar_Get("gl_playermip", "0", 0);
+ gl_monolightmap = ri.Cvar_Get("gl_monolightmap", "0", 0);
+ gl_driver = ri.Cvar_Get("gl_driver", "opengl32", Globals.CVAR_ARCHIVE);
+ gl_texturemode = ri.Cvar_Get("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", Globals.CVAR_ARCHIVE);
+ gl_texturealphamode = ri.Cvar_Get("gl_texturealphamode", "default", Globals.CVAR_ARCHIVE);
+ gl_texturesolidmode = ri.Cvar_Get("gl_texturesolidmode", "default", Globals.CVAR_ARCHIVE);
+ gl_lockpvs = ri.Cvar_Get("gl_lockpvs", "0", 0);
+
+ gl_vertex_arrays = ri.Cvar_Get("gl_vertex_arrays", "1", Globals.CVAR_ARCHIVE);
+
+ gl_ext_swapinterval = ri.Cvar_Get("gl_ext_swapinterval", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_palettedtexture = ri.Cvar_Get("gl_ext_palettedtexture", "0", Globals.CVAR_ARCHIVE);
+ gl_ext_multitexture = ri.Cvar_Get("gl_ext_multitexture", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_pointparameters = ri.Cvar_Get("gl_ext_pointparameters", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_compiled_vertex_array = ri.Cvar_Get("gl_ext_compiled_vertex_array", "1", Globals.CVAR_ARCHIVE);
+
+ gl_drawbuffer = ri.Cvar_Get("gl_drawbuffer", "GL_BACK", 0);
+ gl_swapinterval = ri.Cvar_Get("gl_swapinterval", "0", Globals.CVAR_ARCHIVE);
+
+ gl_saturatelighting = ri.Cvar_Get("gl_saturatelighting", "0", 0);
+
+ gl_3dlabs_broken = ri.Cvar_Get("gl_3dlabs_broken", "1", Globals.CVAR_ARCHIVE);
+
+ vid_fullscreen = ri.Cvar_Get("vid_fullscreen", "0", Globals.CVAR_ARCHIVE);
+ vid_gamma = ri.Cvar_Get("vid_gamma", "1.0", Globals.CVAR_ARCHIVE);
+ vid_ref = ri.Cvar_Get("vid_ref", "fastjogl", Globals.CVAR_ARCHIVE);
+
+ ri.Cmd_AddCommand("imagelist", new xcommand_t() {
+ public void execute() {
+ GL_ImageList_f();
+ }
+ });
+
+ ri.Cmd_AddCommand("screenshot", new xcommand_t() {
+ public void execute() {
+ GL_ScreenShot_f();
+ }
+ });
+ ri.Cmd_AddCommand("modellist", new xcommand_t() {
+ public void execute() {
+ Mod_Modellist_f();
+ }
+ });
+ ri.Cmd_AddCommand("gl_strings", new xcommand_t() {
+ public void execute() {
+ GL_Strings_f();
+ }
+ });
+ }
+
+ /*
+ ==================
+ R_SetMode
+ ==================
+ */
+ protected boolean R_SetMode() {
+
+ int err; // enum rserr_t
+ boolean fullscreen;
+
+// if (vid_fullscreen.modified && !gl_config.allow_cds) {
+// ri.Con_Printf(Defines.PRINT_ALL, "R_SetMode() - CDS not allowed with this driver\n");
+// ri.Cvar_SetValue("vid_fullscreen", (vid_fullscreen.value > 0.0f) ? 0.0f : 1.0f);
+// vid_fullscreen.modified = false;
+// }
+
+ fullscreen = (vid_fullscreen.value > 0.0f);
+
+ vid_fullscreen.modified = false;
+ gl_mode.modified = false;
+
+ Dimension dim = new Dimension(vid.width, vid.height);
+
+ if ((err = GLimp_SetMode(dim, (int) gl_mode.value, fullscreen)) == rserr_ok) {
+ gl_state.prev_mode = (int) gl_mode.value;
+ }
+ else {
+ if (err == rserr_invalid_fullscreen) {
+ ri.Cvar_SetValue("vid_fullscreen", 0);
+ vid_fullscreen.modified = false;
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - fullscreen unavailable in this mode\n");
+ if ((err = GLimp_SetMode(dim, (int) gl_mode.value, false)) == rserr_ok)
+ return true;
+ }
+ else if (err == rserr_invalid_mode) {
+ ri.Cvar_SetValue("gl_mode", gl_state.prev_mode);
+ gl_mode.modified = false;
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - invalid mode\n");
+ }
+
+ // try setting it back to something safe
+ if ((err = GLimp_SetMode(dim, gl_state.prev_mode, false)) != rserr_ok) {
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - could not revert to safe mode\n");
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /*
+ ===============
+ R_Init
+ ===============
+ */
+ float[] r_turbsin = new float[256];
+
+ protected boolean R_Init(int vid_xpos, int vid_ypos) {
+
+ assert(Warp.SIN.length == 256) : "warpsin table bug";
+
+ // fill r_turbsin
+ for (int j = 0; j < 256; j++) {
+ r_turbsin[j] = Warp.SIN[j] * 0.5f;
+ }
+
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl version: " + REF_VERSION + '\n');
+
+ Draw_GetPalette();
+
+ R_Register();
+
+ // initialize our QGL dynamic bindings
+ if (!QGL_Init(gl_driver.string)) {
+ QGL_Shutdown();
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl::R_Init() - could not load \"" + gl_driver.string + "\"\n");
+ return false;
+ }
+
+ // initialize OS-specific parts of OpenGL
+ if (!GLimp_Init(vid_xpos, vid_ypos)) {
+ QGL_Shutdown();
+ return false;
+ }
+
+ // set our "safe" modes
+ gl_state.prev_mode = 3;
+
+ // create the window and set up the context
+ if (!R_SetMode()) {
+ QGL_Shutdown();
+ ri.Con_Printf(Defines.PRINT_ALL, "ref_gl::R_Init() - could not R_SetMode()\n");
+ return false;
+ }
+ return true;
+ }
+
+ boolean R_Init2() {
+ ri.Vid_MenuInit();
+
+ /*
+ ** get our various GL strings
+ */
+ gl_config.vendor_string = gl.glGetString(GL.GL_VENDOR);
+ ri.Con_Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n');
+ gl_config.renderer_string = gl.glGetString(GL.GL_RENDERER);
+ ri.Con_Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n');
+ gl_config.version_string = gl.glGetString(GL.GL_VERSION);
+ ri.Con_Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n');
+ gl_config.extensions_string = gl.glGetString(GL.GL_EXTENSIONS);
+ ri.Con_Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n');
+
+ String renderer_buffer = gl_config.renderer_string.toLowerCase();
+ String vendor_buffer = gl_config.vendor_string.toLowerCase();
+
+ if (renderer_buffer.indexOf("voodoo") >= 0) {
+ if (renderer_buffer.indexOf("rush") < 0)
+ gl_config.renderer = GL_RENDERER_VOODOO;
+ else
+ gl_config.renderer = GL_RENDERER_VOODOO_RUSH;
+ }
+ else if (vendor_buffer.indexOf("sgi") >= 0)
+ gl_config.renderer = GL_RENDERER_SGI;
+ else if (renderer_buffer.indexOf("permedia") >= 0)
+ gl_config.renderer = GL_RENDERER_PERMEDIA2;
+ else if (renderer_buffer.indexOf("glint") >= 0)
+ gl_config.renderer = GL_RENDERER_GLINT_MX;
+ else if (renderer_buffer.indexOf("glzicd") >= 0)
+ gl_config.renderer = GL_RENDERER_REALIZM;
+ else if (renderer_buffer.indexOf("gdi") >= 0)
+ gl_config.renderer = GL_RENDERER_MCD;
+ else if (renderer_buffer.indexOf("pcx2") >= 0)
+ gl_config.renderer = GL_RENDERER_PCX2;
+ else if (renderer_buffer.indexOf("verite") >= 0)
+ gl_config.renderer = GL_RENDERER_RENDITION;
+ else
+ gl_config.renderer = GL_RENDERER_OTHER;
+
+ String monolightmap = gl_monolightmap.string.toUpperCase();
+ if (monolightmap.length() < 2 || monolightmap.charAt(1) != 'F') {
+ if (gl_config.renderer == GL_RENDERER_PERMEDIA2) {
+ ri.Cvar_Set("gl_monolightmap", "A");
+ ri.Con_Printf(Defines.PRINT_ALL, "...using gl_monolightmap 'a'\n");
+ }
+ else if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) {
+ ri.Cvar_Set("gl_monolightmap", "0");
+ }
+ else {
+ ri.Cvar_Set("gl_monolightmap", "0");
+ }
+ }
+
+ // power vr can't have anything stay in the framebuffer, so
+ // the screen needs to redraw the tiled background every frame
+ if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) {
+ ri.Cvar_Set("scr_drawall", "1");
+ }
+ else {
+ ri.Cvar_Set("scr_drawall", "0");
+ }
+
+ // #ifdef __linux__
+ ri.Cvar_SetValue("gl_finish", 1);
+ // #endif
+
+ // MCD has buffering issues
+ if (gl_config.renderer == GL_RENDERER_MCD) {
+ ri.Cvar_SetValue("gl_finish", 1);
+ }
+
+ if ((gl_config.renderer & GL_RENDERER_3DLABS) != 0) {
+ if (gl_3dlabs_broken.value != 0.0f)
+ gl_config.allow_cds = false;
+ else
+ gl_config.allow_cds = true;
+ }
+ else {
+ gl_config.allow_cds = true;
+ }
+
+ if (gl_config.allow_cds)
+ ri.Con_Printf(Defines.PRINT_ALL, "...allowing CDS\n");
+ else
+ ri.Con_Printf(Defines.PRINT_ALL, "...disabling CDS\n");
+
+ /*
+ ** grab extensions
+ */
+ if (gl_config.extensions_string.indexOf("GL_EXT_compiled_vertex_array") >= 0
+ || gl_config.extensions_string.indexOf("GL_SGI_compiled_vertex_array") >= 0) {
+ ri.Con_Printf(Defines.PRINT_ALL, "...enabling GL_EXT_compiled_vertex_array\n");
+ // qglLockArraysEXT = ( void * ) qwglGetProcAddress( "glLockArraysEXT" );
+ if (gl_ext_compiled_vertex_array.value != 0.0f)
+ qglLockArraysEXT = true;
+ else
+ qglLockArraysEXT = false;
+ // qglUnlockArraysEXT = ( void * ) qwglGetProcAddress( "glUnlockArraysEXT" );
+ //qglUnlockArraysEXT = true;
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n");
+ qglLockArraysEXT = false;
+ }
+
+ if (gl_config.extensions_string.indexOf("WGL_EXT_swap_control") >= 0) {
+ qwglSwapIntervalEXT = true;
+ ri.Con_Printf(Defines.PRINT_ALL, "...enabling WGL_EXT_swap_control\n");
+ } else {
+ qwglSwapIntervalEXT = false;
+ ri.Con_Printf(Defines.PRINT_ALL, "...WGL_EXT_swap_control not found\n");
+ }
+
+ if (gl_config.extensions_string.indexOf("GL_EXT_point_parameters") >= 0) {
+ if (gl_ext_pointparameters.value != 0.0f) {
+ // qglPointParameterfEXT = ( void (APIENTRY *)( GLenum, GLfloat ) ) qwglGetProcAddress( "glPointParameterfEXT" );
+ qglPointParameterfEXT = true;
+ // qglPointParameterfvEXT = ( void (APIENTRY *)( GLenum, const GLfloat * ) ) qwglGetProcAddress( "glPointParameterfvEXT" );
+ ri.Con_Printf(Defines.PRINT_ALL, "...using GL_EXT_point_parameters\n");
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_point_parameters\n");
+ }
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...GL_EXT_point_parameters not found\n");
+ }
+
+ // #ifdef __linux__
+ // if ( strstr( gl_config.extensions_string, "3DFX_set_global_palette" ))
+ // {
+ // if ( gl_ext_palettedtexture->value )
+ // {
+ // ri.Con_Printf( Defines.PRINT_ALL, "...using 3DFX_set_global_palette\n" );
+ // qgl3DfxSetPaletteEXT = ( void ( APIENTRY * ) (GLuint *) )qwglGetProcAddress( "gl3DfxSetPaletteEXT" );
+ //// qglColorTableEXT = Fake_glColorTableEXT;
+ // }
+ // else
+ // {
+ // ri.Con_Printf( Defines.PRINT_ALL, "...ignoring 3DFX_set_global_palette\n" );
+ // }
+ // }
+ // else
+ // {
+ // ri.Con_Printf( Defines.PRINT_ALL, "...3DFX_set_global_palette not found\n" );
+ // }
+ // #endif
+
+ if (!qglColorTableEXT
+ && gl_config.extensions_string.indexOf("GL_EXT_paletted_texture") >= 0
+ && gl_config.extensions_string.indexOf("GL_EXT_shared_texture_palette") >= 0) {
+ if (gl_ext_palettedtexture.value != 0.0f) {
+ ri.Con_Printf(Defines.PRINT_ALL, "...using GL_EXT_shared_texture_palette\n");
+ qglColorTableEXT = false; // true; TODO jogl bug
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_shared_texture_palette\n");
+ qglColorTableEXT = false;
+ }
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...GL_EXT_shared_texture_palette not found\n");
+ }
+
+ if (gl_config.extensions_string.indexOf("GL_ARB_multitexture") >= 0) {
+ ri.Con_Printf(Defines.PRINT_ALL, "...using GL_ARB_multitexture\n");
+ qglActiveTextureARB = true;
+ GL_TEXTURE0 = GL.GL_TEXTURE0_ARB;
+ GL_TEXTURE1 = GL.GL_TEXTURE1_ARB;
+ }
+ else {
+ ri.Con_Printf(Defines.PRINT_ALL, "...GL_ARB_multitexture not found\n");
+ }
+
+ if (!(qglActiveTextureARB))
+ return false;
+
+ GL_SetDefaultState();
+
+ GL_InitImages();
+ Mod_Init();
+ R_InitParticleTexture();
+ Draw_InitLocal();
+
+ int err = gl.glGetError();
+ if (err != GL.GL_NO_ERROR)
+ ri.Con_Printf(
+ Defines.PRINT_ALL,
+ "glGetError() = 0x%x\n\t%s\n",
+ new Vargs(2).add(err).add("" + gl.glGetString(err)));
+
+ return true;
+ }
+
+ /*
+ ===============
+ R_Shutdown
+ ===============
+ */
+ protected void R_Shutdown() {
+ ri.Cmd_RemoveCommand("modellist");
+ ri.Cmd_RemoveCommand("screenshot");
+ ri.Cmd_RemoveCommand("imagelist");
+ ri.Cmd_RemoveCommand("gl_strings");
+
+ Mod_FreeAll();
+
+ GL_ShutdownImages();
+
+ /*
+ * shut down OS specific OpenGL stuff like contexts, etc.
+ */
+ GLimp_Shutdown();
+
+ /*
+ * shutdown our QGL subsystem
+ */
+ QGL_Shutdown();
+ }
+
+ /*
+ @@@@@@@@@@@@@@@@@@@@@
+ R_BeginFrame
+ @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected void R_BeginFrame(float camera_separation) {
+
+ gl_state.camera_separation = camera_separation;
+
+ /*
+ ** change modes if necessary
+ */
+ if (gl_mode.modified || vid_fullscreen.modified) {
+ // FIXME: only restart if CDS is required
+ cvar_t ref;
+
+ ref = ri.Cvar_Get("vid_ref", "fastjogl", 0);
+ ref.modified = true;
+ }
+
+ if (gl_log.modified) {
+ GLimp_EnableLogging((gl_log.value != 0.0f));
+ gl_log.modified = false;
+ }
+
+ if (gl_log.value != 0.0f) {
+ GLimp_LogNewFrame();
+ }
+
+ /*
+ ** update 3Dfx gamma -- it is expected that a user will do a vid_restart
+ ** after tweaking this value
+ */
+ if (vid_gamma.modified) {
+ vid_gamma.modified = false;
+
+ if ((gl_config.renderer & GL_RENDERER_VOODOO) != 0) {
+ // wird erstmal nicht gebraucht
+
+ /*
+ char envbuffer[1024];
+ float g;
+
+ g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F;
+ Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g );
+ putenv( envbuffer );
+ Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g );
+ putenv( envbuffer );
+ */
+ ri.Con_Printf(Defines.PRINT_DEVELOPER, "gamma anpassung fuer VOODOO nicht gesetzt");
+ }
+ }
+
+ GLimp_BeginFrame(camera_separation);
+
+ /*
+ ** go into 2D mode
+ */
+ gl.glViewport(0, 0, vid.width, vid.height);
+ gl.glMatrixMode(GL.GL_PROJECTION);
+ gl.glLoadIdentity();
+ gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999);
+ gl.glMatrixMode(GL.GL_MODELVIEW);
+ gl.glLoadIdentity();
+ gl.glDisable(GL.GL_DEPTH_TEST);
+ gl.glDisable(GL.GL_CULL_FACE);
+ gl.glDisable(GL.GL_BLEND);
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ gl.glColor4f(1, 1, 1, 1);
+
+ /*
+ ** draw buffer stuff
+ */
+ if (gl_drawbuffer.modified) {
+ gl_drawbuffer.modified = false;
+
+ if (gl_state.camera_separation == 0 || !gl_state.stereo_enabled) {
+ if (gl_drawbuffer.string.equalsIgnoreCase("GL_FRONT"))
+ gl.glDrawBuffer(GL.GL_FRONT);
+ else
+ gl.glDrawBuffer(GL.GL_BACK);
+ }
+ }
+
+ /*
+ ** texturemode stuff
+ */
+ if (gl_texturemode.modified) {
+ GL_TextureMode(gl_texturemode.string);
+ gl_texturemode.modified = false;
+ }
+
+ if (gl_texturealphamode.modified) {
+ GL_TextureAlphaMode(gl_texturealphamode.string);
+ gl_texturealphamode.modified = false;
+ }
+
+ if (gl_texturesolidmode.modified) {
+ GL_TextureSolidMode(gl_texturesolidmode.string);
+ gl_texturesolidmode.modified = false;
+ }
+
+ /*
+ ** swapinterval stuff
+ */
+ GL_UpdateSwapInterval();
+
+ //
+ // clear screen if desired
+ //
+ R_Clear();
+ }
+
+ int[] r_rawpalette = new int[256];
+
+ /*
+ =============
+ R_SetPalette
+ =============
+ */
+ protected void R_SetPalette(byte[] palette) {
+ // 256 RGB values (768 bytes)
+ // or null
+ int i;
+ int color = 0;
+
+ if (palette != null) {
+ int j =0;
+ for (i = 0; i < 256; i++) {
+ color = (palette[j++] & 0xFF) << 0;
+ color |= (palette[j++] & 0xFF) << 8;
+ color |= (palette[j++] & 0xFF) << 16;
+ color |= 0xFF000000;
+ r_rawpalette[i] = color;
+ }
+ }
+ else {
+ for (i = 0; i < 256; i++) {
+ r_rawpalette[i] = d_8to24table[i] | 0xff000000;
+ }
+ }
+ GL_SetTexturePalette(r_rawpalette);
+
+ gl.glClearColor(0, 0, 0, 0);
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT);
+ gl.glClearColor(1f, 0f, 0.5f, 0.5f);
+ }
+
+ static final int NUM_BEAM_SEGS = 6;
+ float[][] start_points = new float[NUM_BEAM_SEGS][3];
+ // array of vec3_t
+ float[][] end_points = new float[NUM_BEAM_SEGS][3]; // array of vec3_t
+
+ /*
+ ** R_DrawBeam
+ */
+ void R_DrawBeam(entity_t e) {
+
+ int i;
+ float r, g, b;
+
+ float[] perpvec = { 0, 0, 0 }; // vec3_t
+ float[] direction = { 0, 0, 0 }; // vec3_t
+ float[] normalized_direction = { 0, 0, 0 }; // vec3_t
+
+ float[] oldorigin = { 0, 0, 0 }; // vec3_t
+ float[] origin = { 0, 0, 0 }; // vec3_t
+
+ oldorigin[0] = e.oldorigin[0];
+ oldorigin[1] = e.oldorigin[1];
+ oldorigin[2] = e.oldorigin[2];
+
+ origin[0] = e.origin[0];
+ origin[1] = e.origin[1];
+ origin[2] = e.origin[2];
+
+ normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
+ normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
+ normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
+
+ if (Math3D.VectorNormalize(normalized_direction) == 0.0f)
+ return;
+
+ Math3D.PerpendicularVector(perpvec, normalized_direction);
+ Math3D.VectorScale(perpvec, e.frame / 2, perpvec);
+
+ for (i = 0; i < 6; i++) {
+ Math3D.RotatePointAroundVector(
+ start_points[i],
+ normalized_direction,
+ perpvec,
+ (360.0f / NUM_BEAM_SEGS) * i);
+
+ Math3D.VectorAdd(start_points[i], origin, start_points[i]);
+ Math3D.VectorAdd(start_points[i], direction, end_points[i]);
+ }
+
+ gl.glDisable(GL.GL_TEXTURE_2D);
+ gl.glEnable(GL.GL_BLEND);
+ gl.glDepthMask(false);
+
+ r = (d_8to24table[e.skinnum & 0xFF]) & 0xFF;
+ g = (d_8to24table[e.skinnum & 0xFF] >> 8) & 0xFF;
+ b = (d_8to24table[e.skinnum & 0xFF] >> 16) & 0xFF;
+
+ r *= 1 / 255.0f;
+ g *= 1 / 255.0f;
+ b *= 1 / 255.0f;
+
+ gl.glColor4f(r, g, b, e.alpha);
+
+ gl.glBegin(GL.GL_TRIANGLE_STRIP);
+
+ float[] v;
+
+ for (i = 0; i < NUM_BEAM_SEGS; i++) {
+ v = start_points[i];
+ gl.glVertex3f(v[0], v[1], v[2]);
+ v = end_points[i];
+ gl.glVertex3f(v[0], v[1], v[2]);
+ v = start_points[(i + 1) % NUM_BEAM_SEGS];
+ gl.glVertex3f(v[0], v[1], v[2]);
+ v = end_points[(i + 1) % NUM_BEAM_SEGS];
+ gl.glVertex3f(v[0], v[1], v[2]);
+ }
+ gl.glEnd();
+
+ gl.glEnable(GL.GL_TEXTURE_2D);
+ gl.glDisable(GL.GL_BLEND);
+ gl.glDepthMask(true);
+ }
+
+}
diff --git a/src/jake2/render/fastjogl/Mesh.java b/src/jake2/render/fastjogl/Mesh.java
new file mode 100644
index 0000000..e7da997
--- /dev/null
+++ b/src/jake2/render/fastjogl/Mesh.java
@@ -0,0 +1,753 @@
+/*
+ * Mesh.java
+ * Copyright (C) 2003
+ *
+ * $Id: Mesh.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import net.java.games.gluegen.runtime.BufferFactory;
+import net.java.games.jogl.GL;
+import net.java.games.jogl.util.BufferUtils;
+import jake2.Defines;
+import jake2.Globals;
+import jake2.client.entity_t;
+import jake2.qcommon.qfiles;
+import jake2.render.image_t;
+import jake2.util.Math3D;
+
+/**
+ * Mesh
+ *
+ * @author cwei
+ */
+public abstract class Mesh extends Light {
+
+ // g_mesh.c: triangle model functions
+
+ /*
+ =============================================================
+
+ ALIAS MODELS
+
+ =============================================================
+ */
+
+ static final int NUMVERTEXNORMALS = 162;
+
+ float[][] r_avertexnormals = Anorms.VERTEXNORMALS;
+ float[] shadevector = {0, 0, 0};
+ float[] shadelight = {0, 0, 0};
+
+ // precalculated dot products for quantized angles
+ static final int SHADEDOT_QUANT = 16;
+
+ float[][] r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS;
+
+ float[] shadedots = r_avertexnormal_dots[0];
+
+ void GL_LerpVerts( int nverts, qfiles.dtrivertx_t[] v, qfiles.dtrivertx_t[] ov, qfiles.dtrivertx_t[] verts, FloatBuffer lerp, float[] move, float[] frontv, float[] backv )
+ {
+ int i;
+ int lerpIndex = 0;
+
+ int[] ovv;
+ int[] vv;
+
+ //PMM -- added RF_SHELL_DOUBLE, RF_SHELL_HALF_DAM
+ if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0 )
+ {
+ float[] normal;
+ int j = 0;
+ for (i=0 ; i < nverts; i++/* , v++, ov++, lerp+=4 */)
+ {
+ normal = r_avertexnormals[verts[i].lightnormalindex];
+ ovv = ov[i].v;
+ vv = v[i].v;
+
+ lerp.put(j, move[0] + ovv[0]*backv[0] + vv[0]*frontv[0] + normal[0] * Defines.POWERSUIT_SCALE);
+ lerp.put(j + 1, move[1] + ovv[1]*backv[1] + vv[1]*frontv[1] + normal[1] * Defines.POWERSUIT_SCALE);
+ lerp.put(j + 2, move[2] + ovv[2]*backv[2] + vv[2]*frontv[2] + normal[2] * Defines.POWERSUIT_SCALE);
+ j+=3;
+ }
+ }
+ else
+ {
+ int j = 0;
+ for (i=0 ; i < nverts; i++ /* , v++, ov++, lerp+=4 */)
+ {
+ ovv = ov[i].v;
+ vv = v[i].v;
+
+ lerp.put(j, move[0] + ovv[0]*backv[0] + vv[0]*frontv[0]);
+ lerp.put(j + 1, move[1] + ovv[1]*backv[1] + vv[1]*frontv[1]);
+ lerp.put(j + 2, move[2] + ovv[2]*backv[2] + vv[2]*frontv[2]);
+ j+=3;
+ }
+ }
+ }
+
+ FloatBuffer colorArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 4);
+ FloatBuffer vertexArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 3);
+ FloatBuffer textureArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 2);
+ boolean isFilled = false;
+ float[] tmpVec = {0, 0, 0};
+ float[][] vectors = {
+ {0, 0, 0}, {0, 0, 0}, {0, 0, 0} // 3 mal vec3_t
+ };
+
+ /*
+ =============
+ GL_DrawAliasFrameLerp
+
+ interpolates between two frames and origins
+ FIXME: batch lerp all vertexes
+ =============
+ */
+
+ void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp)
+ {
+ float l;
+ qfiles.daliasframe_t frame, oldframe;
+ qfiles.dtrivertx_t[] v, ov, verts;
+
+ int[] order;
+ int orderIndex = 0;
+ int count;
+
+ float frontlerp;
+ float alpha;
+
+ float[] move = {0, 0, 0}; // vec3_t
+ float[] delta = {0, 0, 0}; // vec3_t
+
+ float[] frontv = {0, 0, 0}; // vec3_t
+ float[] backv = {0, 0, 0}; // vec3_t
+
+ int i;
+ int index_xyz;
+
+ frame = paliashdr.aliasFrames[currententity.frame];
+
+ verts = v = frame.verts;
+
+ oldframe = paliashdr.aliasFrames[currententity.oldframe];
+
+ ov = oldframe.verts;
+
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0)
+ alpha = currententity.alpha;
+ else
+ alpha = 1.0f;
+
+ // PMM - added double shell
+ if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
+ gl.glDisable( GL.GL_TEXTURE_2D );
+
+ frontlerp = 1.0f - backlerp;
+
+ // move should be the delta back to the previous frame * backlerp
+ Math3D.VectorSubtract (currententity.oldorigin, currententity.origin, delta);
+ Math3D.AngleVectors (currententity.angles, vectors[0], vectors[1], vectors[2]);
+
+ move[0] = Math3D.DotProduct (delta, vectors[0]); // forward
+ move[1] = -Math3D.DotProduct (delta, vectors[1]); // left
+ move[2] = Math3D.DotProduct (delta, vectors[2]); // up
+
+ Math3D.VectorAdd (move, oldframe.translate, move);
+
+ for (i=0 ; i<3 ; i++)
+ {
+ move[i] = backlerp*move[i] + frontlerp*frame.translate[i];
+ }
+
+ for (i=0 ; i<3 ; i++)
+ {
+ frontv[i] = frontlerp*frame.scale[i];
+ backv[i] = backlerp*oldframe.scale[i];
+ }
+
+ // ab hier wird optimiert
+
+ GL_LerpVerts( paliashdr.num_xyz, v, ov, verts, vertexArrayBuf, move, frontv, backv );
+
+ //gl.glEnableClientState( GL.GL_VERTEX_ARRAY );
+ gl.glVertexPointer( 3, GL.GL_FLOAT, 0, vertexArrayBuf );
+
+ // PMM - added double damage shell
+ if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
+ {
+ gl.glColor4f( shadelight[0], shadelight[1], shadelight[2], alpha );
+ }
+ else
+ {
+ gl.glEnableClientState( GL.GL_COLOR_ARRAY );
+ gl.glColorPointer( 4, GL.GL_FLOAT, 0, colorArrayBuf );
+
+ //
+ // pre light everything
+ //
+ FloatBuffer color = colorArrayBuf;
+ int j = 0;
+ for ( i = 0; i < paliashdr.num_xyz; i++ )
+ {
+ l = shadedots[verts[i].lightnormalindex];
+ color.put(j++, l * shadelight[0]);
+ color.put(j++, l * shadelight[1]);
+ color.put(j++, l * shadelight[2]);
+ color.put(j++, alpha);
+ }
+ }
+
+ gl.glClientActiveTextureARB(GL_TEXTURE0);
+ gl.glTexCoordPointer( 2, GL.GL_FLOAT, 0, textureArrayBuf);
+ //gl.glEnableClientState( GL.GL_TEXTURE_COORD_ARRAY);
+
+ int pos = 0;
+ int[] counts = paliashdr.counts;
+
+ IntBuffer srcIndexBuf = null;
+
+ FloatBuffer dstTextureCoords = textureArrayBuf;
+ FloatBuffer srcTextureCoords = paliashdr.textureCoordBuf;
+
+ int size = 0;
+ int dstIndex = 0;
+ int srcIndex = 0;
+
+ for (int j = 0; j < counts.length; j++) {
+
+ // get the vertex count and primitive type
+ count = counts[j];
+ if (count == 0)
+ break; // done
+
+ srcIndexBuf = paliashdr.indexElements[j];
+
+ size = (count < 0) ? -count + pos : count + pos;
+ for (int k = pos; k < size; k++) {
+ srcIndex = 2 * k;
+ dstIndex = 2 * srcIndexBuf.get(k-pos);
+ dstTextureCoords.put(dstIndex, srcTextureCoords.get(srcIndex));
+ dstTextureCoords.put(dstIndex + 1, srcTextureCoords.get(srcIndex + 1));
+ }
+
+ if (count < 0) {
+ count = -count;
+ gl.glDrawElements(GL.GL_TRIANGLE_FAN, count, GL.GL_UNSIGNED_INT, srcIndexBuf);
+ } else {
+ gl.glDrawElements(GL.GL_TRIANGLE_STRIP, count, GL.GL_UNSIGNED_INT, srcIndexBuf);
+ }
+ pos += count;
+ }
+
+ // PMM - added double damage shell
+ if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0 )
+ gl.glEnable( GL.GL_TEXTURE_2D );
+
+ gl.glDisableClientState( GL.GL_COLOR_ARRAY );
+
+ }
+
+ /*
+ =============
+ GL_DrawAliasShadow
+ =============
+ */
+ void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum)
+ {
+ qfiles.dtrivertx_t[] verts;
+ int[] order;
+ float[] point = {0, 0, 0};
+ float height, lheight;
+ int count;
+ qfiles.daliasframe_t frame;
+
+ lheight = currententity.origin[2] - lightspot[2];
+
+ frame = paliashdr.aliasFrames[currententity.frame];
+
+ verts = frame.verts;
+
+ height = 0;
+
+ order = paliashdr.glCmds;
+
+ height = -lheight + 1.0f;
+
+ int orderIndex = 0;
+ int index = 0;
+
+ // TODO shadow drawing with vertex arrays
+
+ while (true)
+ {
+ // get the vertex count and primitive type
+ count = order[orderIndex++];
+ if (count == 0)
+ break; // done
+ if (count < 0)
+ {
+ count = -count;
+ gl.glBegin (GL.GL_TRIANGLE_FAN);
+ }
+ else
+ gl.glBegin (GL.GL_TRIANGLE_STRIP);
+
+ do
+ {
+ index = order[orderIndex + 2] * 3;
+ point[0] = vertexArrayBuf.get(index);
+ point[1] = vertexArrayBuf.get(index + 1);
+ point[2] = vertexArrayBuf.get(index + 2);
+
+ point[0] -= shadevector[0]*(point[2]+lheight);
+ point[1] -= shadevector[1]*(point[2]+lheight);
+ point[2] = height;
+ gl.glVertex3f(point[0], point[1], point[2]);
+
+ orderIndex += 3;
+
+ } while (--count != 0);
+
+ gl.glEnd ();
+ }
+ }
+
+
+ /*
+ ** R_CullAliasModel
+ */
+ boolean R_CullAliasModel( float[][] bbox, entity_t e )
+ {
+ int i;
+ float[] mins = {0, 0, 0};
+ float[] maxs = {0, 0, 0};
+
+ qfiles.dmdl_t paliashdr;
+
+ float[] thismins = {0, 0, 0};
+ float[] oldmins = {0, 0, 0};
+ float[] thismaxs = {0, 0, 0};
+ float[] oldmaxs = {0, 0, 0};
+ qfiles.daliasframe_t pframe, poldframe;
+ float[] angles = {0, 0, 0};
+
+ paliashdr = (qfiles.dmdl_t)currentmodel.extradata;
+
+ if ( ( e.frame >= paliashdr.num_frames ) || ( e.frame < 0 ) )
+ {
+ ri.Con_Printf (Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name +": no such frame " + e.frame + '\n');
+ e.frame = 0;
+ }
+ if ( ( e.oldframe >= paliashdr.num_frames ) || ( e.oldframe < 0 ) )
+ {
+ ri.Con_Printf (Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such oldframe " + e.oldframe + '\n');
+ e.oldframe = 0;
+ }
+
+ pframe = paliashdr.aliasFrames[e.frame];
+ poldframe = paliashdr.aliasFrames[e.oldframe];
+
+ /*
+ ** compute axially aligned mins and maxs
+ */
+ if ( pframe == poldframe )
+ {
+ for ( i = 0; i < 3; i++ )
+ {
+ mins[i] = pframe.translate[i];
+ maxs[i] = mins[i] + pframe.scale[i]*255;
+ }
+ }
+ else
+ {
+ for ( i = 0; i < 3; i++ )
+ {
+ thismins[i] = pframe.translate[i];
+ thismaxs[i] = thismins[i] + pframe.scale[i]*255;
+
+ oldmins[i] = poldframe.translate[i];
+ oldmaxs[i] = oldmins[i] + poldframe.scale[i]*255;
+
+ if ( thismins[i] < oldmins[i] )
+ mins[i] = thismins[i];
+ else
+ mins[i] = oldmins[i];
+
+ if ( thismaxs[i] > oldmaxs[i] )
+ maxs[i] = thismaxs[i];
+ else
+ maxs[i] = oldmaxs[i];
+ }
+ }
+
+ /*
+ ** compute a full bounding box
+ */
+ for ( i = 0; i < 8; i++ )
+ {
+ float[] tmp = {0, 0, 0};
+
+ if ( (i & 1) != 0 )
+ tmp[0] = mins[0];
+ else
+ tmp[0] = maxs[0];
+
+ if ( (i & 2) != 0)
+ tmp[1] = mins[1];
+ else
+ tmp[1] = maxs[1];
+
+ if ( (i & 4) != 0)
+ tmp[2] = mins[2];
+ else
+ tmp[2] = maxs[2];
+
+ Math3D.VectorCopy( tmp, bbox[i] );
+ }
+
+ /*
+ ** rotate the bounding box
+ */
+ Math3D.VectorCopy( e.angles, angles );
+ angles[YAW] = -angles[YAW];
+ Math3D.AngleVectors( angles, vectors[0], vectors[1], vectors[2] );
+
+ float[] tmp = {0, 0, 0};
+
+ for ( i = 0; i < 8; i++ )
+ {
+ Math3D.VectorCopy( bbox[i], tmp );
+
+ bbox[i][0] = Math3D.DotProduct( vectors[0], tmp );
+ bbox[i][1] = -Math3D.DotProduct( vectors[1], tmp );
+ bbox[i][2] = Math3D.DotProduct( vectors[2], tmp );
+
+ Math3D.VectorAdd( e.origin, bbox[i], bbox[i] );
+ }
+
+ {
+ int p, f;
+ int aggregatemask = ~0; // 0xFFFFFFFF
+
+ for ( p = 0; p < 8; p++ )
+ {
+ int mask = 0;
+
+ for ( f = 0; f < 4; f++ )
+ {
+ float dp = Math3D.DotProduct( frustum[f].normal, bbox[p] );
+
+ if ( ( dp - frustum[f].dist ) < 0 )
+ {
+ mask |= ( 1 << f );
+ }
+ }
+
+ aggregatemask &= mask;
+ }
+
+ if ( aggregatemask != 0 )
+ {
+ return true;
+ }
+
+ return false;
+ }
+ }
+
+
+ // bounding box
+ float[][] bbox = {
+ {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+ {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}
+ };
+
+ /*
+ =================
+ R_DrawAliasModel
+
+ =================
+ */
+ void R_DrawAliasModel(entity_t e)
+ {
+ int i;
+ qfiles.dmdl_t paliashdr;
+ float an;
+
+ image_t skin;
+
+ if ( ( e.flags & Defines.RF_WEAPONMODEL ) == 0)
+ {
+ if ( R_CullAliasModel( bbox, e ) )
+ return;
+ }
+
+ if ( (e.flags & Defines.RF_WEAPONMODEL) != 0 )
+ {
+ if ( r_lefthand.value == 2.0f )
+ return;
+ }
+
+ paliashdr = (qfiles.dmdl_t)currentmodel.extradata;
+
+ //
+ // get lighting information
+ //
+ // PMM - rewrote, reordered to handle new shells & mixing
+ // PMM - 3.20 code .. replaced with original way of doing it to keep mod authors happy
+ //
+ if ( (currententity.flags & ( Defines.RF_SHELL_HALF_DAM | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_RED | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE )) != 0 )
+ {
+ Math3D.VectorClear(shadelight);
+ if ((currententity.flags & Defines.RF_SHELL_HALF_DAM) != 0)
+ {
+ shadelight[0] = 0.56f;
+ shadelight[1] = 0.59f;
+ shadelight[2] = 0.45f;
+ }
+ if ( (currententity.flags & Defines.RF_SHELL_DOUBLE) != 0 )
+ {
+ shadelight[0] = 0.9f;
+ shadelight[1] = 0.7f;
+ }
+ if ( (currententity.flags & Defines.RF_SHELL_RED) != 0 )
+ shadelight[0] = 1.0f;
+ if ( (currententity.flags & Defines.RF_SHELL_GREEN) != 0 )
+ shadelight[1] = 1.0f;
+ if ( (currententity.flags & Defines.RF_SHELL_BLUE) != 0 )
+ shadelight[2] = 1.0f;
+ }
+
+ else if ( (currententity.flags & Defines.RF_FULLBRIGHT) != 0 )
+ {
+ for (i=0 ; i<3 ; i++)
+ shadelight[i] = 1.0f;
+ }
+ else
+ {
+ R_LightPoint (currententity.origin, shadelight);
+
+ // player lighting hack for communication back to server
+ // big hack!
+ if ( (currententity.flags & Defines.RF_WEAPONMODEL) != 0 )
+ {
+ // pick the greatest component, which should be the same
+ // as the mono value returned by software
+ if (shadelight[0] > shadelight[1])
+ {
+ if (shadelight[0] > shadelight[2])
+ r_lightlevel.value = 150*shadelight[0];
+ else
+ r_lightlevel.value = 150*shadelight[2];
+ }
+ else
+ {
+ if (shadelight[1] > shadelight[2])
+ r_lightlevel.value = 150*shadelight[1];
+ else
+ r_lightlevel.value = 150*shadelight[2];
+ }
+ }
+
+ if ( gl_monolightmap.string.charAt(0) != '0' )
+ {
+ float s = shadelight[0];
+
+ if ( s < shadelight[1] )
+ s = shadelight[1];
+ if ( s < shadelight[2] )
+ s = shadelight[2];
+
+ shadelight[0] = s;
+ shadelight[1] = s;
+ shadelight[2] = s;
+ }
+ }
+
+ if ( (currententity.flags & Defines.RF_MINLIGHT) != 0 )
+ {
+ for (i=0 ; i<3 ; i++)
+ if (shadelight[i] > 0.1f)
+ break;
+ if (i == 3)
+ {
+ shadelight[0] = 0.1f;
+ shadelight[1] = 0.1f;
+ shadelight[2] = 0.1f;
+ }
+ }
+
+ if ( (currententity.flags & Defines.RF_GLOW) != 0 )
+ { // bonus items will pulse with time
+ float scale;
+ float min;
+
+ scale = (float)(0.1f * Math.sin(r_newrefdef.time*7));
+ for (i=0 ; i<3 ; i++)
+ {
+ min = shadelight[i] * 0.8f;
+ shadelight[i] += scale;
+ if (shadelight[i] < min)
+ shadelight[i] = min;
+ }
+ }
+
+ // =================
+ // PGM ir goggles color override
+ if ( (r_newrefdef.rdflags & Defines.RDF_IRGOGGLES) != 0 && (currententity.flags & Defines.RF_IR_VISIBLE) != 0)
+ {
+ shadelight[0] = 1.0f;
+ shadelight[1] = 0.0f;
+ shadelight[2] = 0.0f;
+ }
+ // PGM
+ // =================
+
+ shadedots = r_avertexnormal_dots[((int)(currententity.angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
+
+ an = (float)(currententity.angles[1]/180*Math.PI);
+ shadevector[0] = (float)Math.cos(-an);
+ shadevector[1] = (float)Math.sin(-an);
+ shadevector[2] = 1;
+ Math3D.VectorNormalize(shadevector);
+
+ //
+ // locate the proper data
+ //
+
+ c_alias_polys += paliashdr.num_tris;
+
+ //
+ // draw all the triangles
+ //
+ if ( (currententity.flags & Defines.RF_DEPTHHACK) != 0) // hack the depth range to prevent view model from poking into walls
+ gl.glDepthRange(gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin));
+
+ if ( (currententity.flags & Defines.RF_WEAPONMODEL) != 0 && (r_lefthand.value == 1.0f) )
+ {
+ gl.glMatrixMode( GL.GL_PROJECTION );
+ gl.glPushMatrix();
+ gl.glLoadIdentity();
+ gl.glScalef( -1, 1, 1 );
+ MYgluPerspective( r_newrefdef.fov_y, ( float ) r_newrefdef.width / r_newrefdef.height, 4, 4096);
+ gl.glMatrixMode( GL.GL_MODELVIEW );
+
+ gl.glCullFace( GL.GL_BACK );
+ }
+
+ gl.glPushMatrix ();
+ e.angles[PITCH] = -e.angles[PITCH]; // sigh.
+ R_RotateForEntity (e);
+ e.angles[PITCH] = -e.angles[PITCH]; // sigh.
+
+ // select skin
+ if (currententity.skin != null)
+ skin = currententity.skin; // custom player skin
+ else
+ {
+ if (currententity.skinnum >= qfiles.MAX_MD2SKINS)
+ skin = currentmodel.skins[0];
+ else
+ {
+ skin = currentmodel.skins[currententity.skinnum];
+ if (skin == null)
+ skin = currentmodel.skins[0];
+ }
+ }
+ if (skin == null)
+ skin = r_notexture; // fallback...
+ GL_Bind(skin.texnum);
+
+ // draw it
+
+ gl.glShadeModel (GL.GL_SMOOTH);
+
+ GL_TexEnv( GL.GL_MODULATE );
+ if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 )
+ {
+ gl.glEnable (GL.GL_BLEND);
+ }
+
+
+ if ( (currententity.frame >= paliashdr.num_frames)
+ || (currententity.frame < 0) )
+ {
+ ri.Con_Printf (Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name +": no such frame " + currententity.frame + '\n');
+ currententity.frame = 0;
+ currententity.oldframe = 0;
+ }
+
+ if ( (currententity.oldframe >= paliashdr.num_frames)
+ || (currententity.oldframe < 0))
+ {
+ ri.Con_Printf (Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name +": no such oldframe " + currententity.oldframe + '\n');
+ currententity.frame = 0;
+ currententity.oldframe = 0;
+ }
+
+ if ( r_lerpmodels.value == 0.0f)
+ currententity.backlerp = 0;
+
+ GL_DrawAliasFrameLerp(paliashdr, currententity.backlerp);
+
+ GL_TexEnv( GL.GL_REPLACE );
+ gl.glShadeModel (GL.GL_FLAT);
+
+ gl.glPopMatrix ();
+
+ if ( ( currententity.flags & Defines.RF_WEAPONMODEL ) != 0 && ( r_lefthand.value == 1.0F ) )
+ {
+ gl.glMatrixMode( GL.GL_PROJECTION );
+ gl.glPopMatrix();
+ gl.glMatrixMode( GL.GL_MODELVIEW );
+ gl.glCullFace( GL.GL_FRONT );
+ }
+
+ if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 )
+ {
+ gl.glDisable (GL.GL_BLEND);
+ }
+
+ if ( (currententity.flags & Defines.RF_DEPTHHACK) != 0)
+ gl.glDepthRange (gldepthmin, gldepthmax);
+
+ if ( gl_shadows.value != 0.0f && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0)
+ {
+ gl.glPushMatrix ();
+ R_RotateForEntity (e);
+ gl.glDisable (GL.GL_TEXTURE_2D);
+ gl.glEnable (GL.GL_BLEND);
+ gl.glColor4f (0,0,0,0.5f);
+ GL_DrawAliasShadow (paliashdr, currententity.frame );
+ gl.glEnable (GL.GL_TEXTURE_2D);
+ gl.glDisable (GL.GL_BLEND);
+ gl.glPopMatrix ();
+ }
+ gl.glColor4f (1,1,1,1);
+ }
+
+}
diff --git a/src/jake2/render/fastjogl/Misc.java b/src/jake2/render/fastjogl/Misc.java
new file mode 100644
index 0000000..bcd2a5f
--- /dev/null
+++ b/src/jake2/render/fastjogl/Misc.java
@@ -0,0 +1,265 @@
+/*
+ * Misc.java
+ * Copyright (C) 2003
+ *
+ * $Id: Misc.java,v 1.1 2004-07-09 06:50:48 hzi 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.fastjogl;
+
+import net.java.games.jogl.GL;
+import net.java.games.jogl.WGL;
+
+import jake2.Defines;
+
+/**
+ * Misc
+ *
+ * @author cwei
+ */
+public abstract class Misc extends Mesh {
+
+ /*
+ ==================
+ R_InitParticleTexture
+ ==================
+ */
+ byte[][] dottexture =
+ {
+ {0,0,0,0,0,0,0,0},
+ {0,0,1,1,0,0,0,0},
+ {0,1,1,1,1,0,0,0},
+ {0,1,1,1,1,0,0,0},
+ {0,0,1,1,0,0,0,0},
+ {0,0,0,0,0,0,0,0},
+ {0,0,0,0,0,0,0,0},
+ {0,0,0,0,0,0,0,0},
+ };
+
+ void R_InitParticleTexture()
+ {
+ int x,y;
+ byte[] data = new byte[8 * 8 * 4];
+
+ //
+ // particle texture
+ //
+ for (x=0 ; x<8 ; x++)
+ {
+ for (y=0 ; y<8 ; y++)
+ {
+ data[y * 32 + x * 4 + 0] = (byte)255;
+ data[y * 32 + x * 4 + 1] = (byte)255;
+ data[y * 32 + x * 4 + 2] = (byte)255;
+ data[y * 32 + x * 4 + 3] = (byte)(dottexture[x][y]*255);
+
+ }
+ }
+ r_particletexture = GL_LoadPic("***particle***", data, 8, 8, it_sprite, 32);
+
+ //
+ // also use this for bad textures, but without alpha
+ //
+ for (x=0 ; x<8 ; x++)
+ {
+ for (y=0 ; y<8 ; y++)
+ {
+ data[y * 32 + x * 4 + 0] = (byte)(dottexture[x&3][y&3]*255);
+ data[y * 32 + x * 4 + 1] = 0; // dottexture[x&3][y&3]*255;
+ data[y * 32 + x * 4 + 2] = 0; //dottexture[x&3][y&3]*255;
+ data[y * 32 + x * 4 + 3] = (byte)255;
+ }
+ }
+ r_notexture = GL_LoadPic("***r_notexture***", data, 8, 8, it_wall, 32);
+ }
+
+
+// /*
+// ==============================================================================
+//
+// SCREEN SHOTS
+//
+// ==============================================================================
+// */
+//
+// typedef struct _TargaHeader {
+// unsigned char id_length, colormap_type, image_type;
+// unsigned short colormap_index, colormap_length;
+// unsigned char colormap_size;
+// unsigned short x_origin, y_origin, width, height;
+// unsigned char pixel_size, attributes;
+// } TargaHeader;
+
+
+ /*
+ ==================
+ GL_ScreenShot_f
+ ==================
+ */
+ void GL_ScreenShot_f()
+ {
+// byte *buffer;
+// char picname[80];
+// char checkname[MAX_OSPATH];
+// int i, c, temp;
+// FILE *f;
+//
+// // create the scrnshots directory if it doesn't exist
+// Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot", ri.FS_Gamedir());
+// Sys_Mkdir (checkname);
+//
+////
+//// find a file name to save it to
+////
+// strcpy(picname,"quake00.tga");
+//
+// for (i=0 ; i<=99 ; i++)
+// {
+// picname[5] = i/10 + '0';
+// picname[6] = i%10 + '0';
+// Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot/%s", ri.FS_Gamedir(), picname);
+// f = fopen (checkname, "r");
+// if (!f)
+// break; // file doesn't exist
+// fclose (f);
+// }
+// if (i==100)
+// {
+// ri.Con_Printf (PRINT_ALL, "SCR_ScreenShot_f: Couldn't create a file\n");
+// return;
+// }
+//
+//
+// buffer = malloc(vid.width*vid.height*3 + 18);
+// memset (buffer, 0, 18);
+// buffer[2] = 2; // uncompressed type
+// buffer[12] = vid.width&255;
+// buffer[13] = vid.width>>8;
+// buffer[14] = vid.height&255;
+// buffer[15] = vid.height>>8;
+// buffer[16] = 24; // pixel size
+//
+// qglReadPixels (0, 0, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, buffer+18 );
+//
+// // swap rgb to bgr
+// c = 18+vid.width*vid.height*3;
+// for (i=18 ; i<c ; i+=3)
+// {
+// temp = buffer[i];
+// buffer[i] = buffer[i+2];
+// buffer[i+2] = temp;
+// }
+//
+// f = fopen (checkname, "rw");
+// fwrite (buffer, 1, c, f);
+// fclose (f);
+//
+// free (buffer);
+// ri.Con_Printf (PRINT_ALL, "Wrote %s\n", picname);
+ }
+
+ /*
+ ** GL_Strings_f
+ */
+ void GL_Strings_f() {
+ ri.Con_Printf (Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n');
+ ri.Con_Printf (Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n');
+ ri.Con_Printf (Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n');
+ ri.Con_Printf (Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n');
+ }
+
+ /*
+ ** GL_SetDefaultState
+ */
+ void GL_SetDefaultState()
+ {
+ gl.glClearColor(1f,0f, 0.5f , 0.5f); // original quake2
+ //gl.glClearColor(0, 0, 0, 0); // replaced with black
+ gl.glCullFace(GL.GL_FRONT);
+ gl.glEnable(GL.GL_TEXTURE_2D);
+
+ gl.glEnable(GL.GL_ALPHA_TEST);
+ gl.glAlphaFunc(GL.GL_GREATER, 0.666f);
+
+ gl.glDisable (GL.GL_DEPTH_TEST);
+ gl.glDisable (GL.GL_CULL_FACE);
+ gl.glDisable (GL.GL_BLEND);
+
+ gl.glColor4f (1,1,1,1);
+
+ gl.glPolygonMode (GL.GL_FRONT_AND_BACK, GL.GL_FILL);
+ gl.glShadeModel (GL.GL_FLAT);
+
+ GL_TextureMode( gl_texturemode.string );
+ GL_TextureAlphaMode( gl_texturealphamode.string );
+ GL_TextureSolidMode( gl_texturesolidmode.string );
+
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_min);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
+
+ gl.glBlendFunc (GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
+
+ GL_TexEnv( GL.GL_REPLACE );
+
+ if ( qglPointParameterfEXT )
+ {
+ float[] attenuations = { gl_particle_att_a.value, gl_particle_att_b.value, gl_particle_att_c.value };
+
+ gl.glEnable( GL.GL_POINT_SMOOTH );
+ gl.glPointParameterfEXT( GL.GL_POINT_SIZE_MIN_EXT, gl_particle_min_size.value );
+ gl.glPointParameterfEXT( GL.GL_POINT_SIZE_MAX_EXT, gl_particle_max_size.value );
+ gl.glPointParameterfvEXT( GL.GL_DISTANCE_ATTENUATION_EXT, attenuations );
+ }
+
+ if ( qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f )
+ {
+ gl.glEnable( GL.GL_SHARED_TEXTURE_PALETTE_EXT );
+
+ GL_SetTexturePalette( d_8to24table );
+ }
+
+ GL_UpdateSwapInterval();
+
+ /*
+ * vertex array extension
+ */
+ gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
+ gl.glClientActiveTextureARB(GL_TEXTURE0);
+ gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
+ }
+
+ void GL_UpdateSwapInterval()
+ {
+ if ( gl_swapinterval.modified )
+ {
+ gl_swapinterval.modified = false;
+ if ( !gl_state.stereo_enabled )
+ {
+ if (qwglSwapIntervalEXT) {
+ ((WGL)gl).wglSwapIntervalEXT((int)gl_swapinterval.value);
+ }
+ }
+ }
+ }
+}
diff --git a/src/jake2/render/fastjogl/Model.java b/src/jake2/render/fastjogl/Model.java
new file mode 100644
index 0000000..4b781be
--- /dev/null
+++ b/src/jake2/render/fastjogl/Model.java
@@ -0,0 +1,1347 @@
+/*
+ * Model.java
+ * Copyright (C) 2003
+ *
+ * $Id: Model.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.game.cplane_t;
+import jake2.game.cvar_t;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.util.Math3D;
+import jake2.util.Vargs;
+
+import java.nio.*;
+import java.util.Arrays;
+import java.util.Vector;
+
+import net.java.games.jogl.util.BufferUtils;
+
+/**
+ * Model
+ *
+ * @author cwei
+ */
+public abstract class Model extends Surf {
+
+ // models.c -- model loading and caching
+
+ model_t loadmodel;
+ int modfilelen;
+
+ byte[] mod_novis = new byte[Defines.MAX_MAP_LEAFS/8];
+
+ static final int MAX_MOD_KNOWN = 512;
+ model_t[] mod_known = new model_t[MAX_MOD_KNOWN];
+ int mod_numknown;
+
+ // the inline * models from the current map are kept seperate
+ model_t[] mod_inline = new model_t[MAX_MOD_KNOWN];
+
+ abstract void GL_SubdivideSurface(msurface_t surface); // Warp.java
+
+ /*
+ ===============
+ Mod_PointInLeaf
+ ===============
+ */
+ mleaf_t Mod_PointInLeaf(float[] p, model_t model)
+ {
+ mnode_t node;
+ float d;
+ cplane_t plane;
+
+ if (model == null || model.nodes == null)
+ ri.Sys_Error (Defines.ERR_DROP, "Mod_PointInLeaf: bad model");
+
+ node = model.nodes[0]; // root node
+ while (true)
+ {
+ if (node.contents != -1)
+ return (mleaf_t)node;
+
+ plane = node.plane;
+ d = Math3D.DotProduct(p, plane.normal) - plane.dist;
+ if (d > 0)
+ node = node.children[0];
+ else
+ node = node.children[1];
+ }
+ // never reached
+ }
+
+
+ byte[] decompressed = new byte[Defines.MAX_MAP_LEAFS / 8];
+ byte[] model_visibility = new byte[Defines.MAX_MAP_VISIBILITY];
+
+ /*
+ ===================
+ Mod_DecompressVis
+ ===================
+ */
+ byte[] Mod_DecompressVis(byte[] in, int offset, model_t model)
+ {
+ int c;
+ byte[] out;
+ int outp, inp;
+ int row;
+
+ row = (model.vis.numclusters+7)>>3;
+ out = decompressed;
+ outp = 0;
+ inp = offset;
+
+ if (in == null)
+ { // no vis info, so make all visible
+ while (row != 0)
+ {
+ out[outp++] = (byte)0xFF;
+ row--;
+ }
+ return decompressed;
+ }
+
+ do
+ {
+ if (in[inp] != 0)
+ {
+ out[outp++] = in[inp++];
+ continue;
+ }
+
+ c = in[inp + 1] & 0xFF;
+ inp += 2;
+ while (c != 0)
+ {
+ out[outp++] = 0;
+ c--;
+ }
+ } while (outp < row);
+
+ return decompressed;
+ }
+
+ /*
+ ==============
+ Mod_ClusterPVS
+ ==============
+ */
+ byte[] Mod_ClusterPVS(int cluster, model_t model)
+ {
+ if (cluster == -1 || model.vis == null)
+ return mod_novis;
+ //return Mod_DecompressVis( (byte *)model.vis + model.vis.bitofs[cluster][Defines.DVIS_PVS], model);
+ return Mod_DecompressVis(model_visibility, model.vis.bitofs[cluster][Defines.DVIS_PVS], model);
+ }
+
+
+// ===============================================================================
+
+ /*
+ ================
+ Mod_Modellist_f
+ ================
+ */
+ void Mod_Modellist_f()
+ {
+ int i;
+ model_t mod;
+ int total;
+
+ total = 0;
+ ri.Con_Printf(Defines.PRINT_ALL,"Loaded models:\n");
+ for (i=0; i < mod_numknown ; i++)
+ {
+ mod = mod_known[i];
+ if (mod.name == "")
+ continue;
+
+ ri.Con_Printf (Defines.PRINT_ALL, "%8i : %s\n", new Vargs(2).add(mod.extradatasize).add(mod.name));
+ total += mod.extradatasize;
+ }
+ ri.Con_Printf (Defines.PRINT_ALL, "Total resident: " + total +'\n');
+ }
+
+ /*
+ ===============
+ Mod_Init
+ ===============
+ */
+ void Mod_Init()
+ {
+ // init mod_known
+ for (int i=0; i < MAX_MOD_KNOWN; i++) {
+ mod_known[i] = new model_t();
+ }
+ Arrays.fill(mod_novis, (byte)0xff);
+ }
+
+ byte[] fileBuffer;
+
+ /*
+ ==================
+ Mod_ForName
+
+ Loads in a model for the given name
+ ==================
+ */
+ model_t Mod_ForName(String name, boolean crash)
+ {
+ model_t mod = null;
+ int i;
+
+ if (name == null || name.length() == 0)
+ ri.Sys_Error(Defines.ERR_DROP, "Mod_ForName: NULL name");
+
+ //
+ // inline models are grabbed only from worldmodel
+ //
+ if (name.charAt(0) == '*')
+ {
+ i = Integer.parseInt(name.substring(1));
+ if (i < 1 || r_worldmodel == null || i >= r_worldmodel.numsubmodels)
+ ri.Sys_Error (Defines.ERR_DROP, "bad inline model number");
+ return mod_inline[i];
+ }
+
+ //
+ // search the currently loaded models
+ //
+ for (i=0; i<mod_numknown ; i++)
+ {
+ mod = mod_known[i];
+
+ if (mod.name == "")
+ continue;
+ if (mod.name.equals(name) )
+ return mod;
+ }
+
+ //
+ // find a free model slot spot
+ //
+ for (i=0; i<mod_numknown ; i++)
+ {
+ mod = mod_known[i];
+
+ if (mod.name == "")
+ break; // free spot
+ }
+ if (i == mod_numknown)
+ {
+ if (mod_numknown == MAX_MOD_KNOWN)
+ ri.Sys_Error (Defines.ERR_DROP, "mod_numknown == MAX_MOD_KNOWN");
+ mod_numknown++;
+ mod = mod_known[i];
+ }
+
+ mod.name = name;
+
+ //
+ // load the file
+ //
+ fileBuffer = ri.FS_LoadFile(name);
+
+ if (fileBuffer == null)
+ {
+ if (crash)
+ ri.Sys_Error(Defines.ERR_DROP, "Mod_NumForName: " + mod.name + " not found");
+
+ mod.name = "";
+ return null;
+ }
+
+ modfilelen = fileBuffer.length;
+
+ loadmodel = mod;
+
+ //
+ // fill it in
+ //
+ ByteBuffer bb = ByteBuffer.wrap(fileBuffer);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ // call the apropriate loader
+
+ bb.mark();
+ int ident = bb.getInt();
+
+ bb.reset();
+
+ switch (ident)
+ {
+ case qfiles.IDALIASHEADER:
+ Mod_LoadAliasModel(mod, bb);
+ break;
+ case qfiles.IDSPRITEHEADER:
+ Mod_LoadSpriteModel(mod, bb);
+ break;
+ case qfiles.IDBSPHEADER:
+ Mod_LoadBrushModel(mod, bb);
+ break;
+ default:
+ ri.Sys_Error(Defines.ERR_DROP,"Mod_NumForName: unknown fileid for " + mod.name);
+ break;
+ }
+
+ this.fileBuffer = null; // free it for garbage collection
+ return mod;
+ }
+
+ /*
+ ===============================================================================
+
+ BRUSHMODEL LOADING
+
+ ===============================================================================
+ */
+
+ byte[] mod_base;
+
+
+ /*
+ =================
+ Mod_LoadLighting
+ =================
+ */
+ void Mod_LoadLighting(lump_t l)
+ {
+ if (l.filelen == 0)
+ {
+ loadmodel.lightdata = null;
+ return;
+ }
+ // memcpy (loadmodel.lightdata, mod_base + l.fileofs, l.filelen);
+ loadmodel.lightdata = new byte[l.filelen];
+ System.arraycopy(mod_base, l.fileofs, loadmodel.lightdata, 0, l.filelen);
+ }
+
+
+ /*
+ =================
+ Mod_LoadVisibility
+ =================
+ */
+ void Mod_LoadVisibility(lump_t l)
+ {
+ int i;
+
+ if (l.filelen == 0)
+ {
+ loadmodel.vis = null;
+ return;
+ }
+
+ System.arraycopy(mod_base, l.fileofs, model_visibility, 0, l.filelen);
+
+ ByteBuffer bb = ByteBuffer.wrap(model_visibility, 0, l.filelen);
+
+ loadmodel.vis = new qfiles.dvis_t(bb.order(ByteOrder.LITTLE_ENDIAN));
+
+ /* done:
+ memcpy (loadmodel.vis, mod_base + l.fileofs, l.filelen);
+
+ loadmodel.vis.numclusters = LittleLong (loadmodel.vis.numclusters);
+ for (i=0 ; i<loadmodel.vis.numclusters ; i++)
+ {
+ loadmodel.vis.bitofs[i][0] = LittleLong (loadmodel.vis.bitofs[i][0]);
+ loadmodel.vis.bitofs[i][1] = LittleLong (loadmodel.vis.bitofs[i][1]);
+ }
+ */
+ }
+
+
+ /*
+ =================
+ Mod_LoadVertexes
+ =================
+ */
+ void Mod_LoadVertexes(lump_t l)
+ {
+ mvertex_t[] vertexes;
+ int i, count;
+
+ if ( (l.filelen % mvertex_t.DISK_SIZE) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / mvertex_t.DISK_SIZE;
+
+ vertexes = new mvertex_t[count];
+
+ loadmodel.vertexes = vertexes;
+ loadmodel.numvertexes = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ vertexes[i] = new mvertex_t(bb);
+ }
+ }
+
+ /*
+ =================
+ RadiusFromBounds
+ =================
+ */
+ float RadiusFromBounds(float[] mins, float[] maxs)
+ {
+ float[] corner = {0, 0, 0};
+
+ for (int i=0 ; i<3 ; i++)
+ {
+ corner[i] = Math.abs(mins[i]) > Math.abs(maxs[i]) ? Math.abs(mins[i]) : Math.abs(maxs[i]);
+ }
+ return Math3D.VectorLength(corner);
+ }
+
+
+ /*
+ =================
+ Mod_LoadSubmodels
+ =================
+ */
+ void Mod_LoadSubmodels(lump_t l)
+ {
+ qfiles.dmodel_t in;
+ mmodel_t[] out;
+ int i, j, count;
+
+ if ((l.filelen % qfiles.dmodel_t.SIZE) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / qfiles.dmodel_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new mmodel_t[count];
+
+ loadmodel.submodels = out;
+ loadmodel.numsubmodels = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ in = new qfiles.dmodel_t(bb);
+ out[i] = new mmodel_t();
+ for (j=0 ; j<3 ; j++)
+ { // spread the mins / maxs by a pixel
+ out[i].mins[j] = in.mins[j] - 1;
+ out[i].maxs[j] = in.maxs[j] + 1;
+ out[i].origin[j] = in.origin[j];
+ }
+ out[i].radius = RadiusFromBounds(out[i].mins, out[i].maxs);
+ out[i].headnode = in.headnode;
+ out[i].firstface = in.firstface;
+ out[i].numfaces = in.numfaces;
+ }
+ }
+
+ /*
+ =================
+ Mod_LoadEdges
+ =================
+ */
+ void Mod_LoadEdges (lump_t l)
+ {
+ medge_t[] edges;
+ int i, count;
+
+ if ( (l.filelen % medge_t.DISK_SIZE) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / medge_t.DISK_SIZE;
+ // out = Hunk_Alloc ( (count + 1) * sizeof(*out));
+ edges = new medge_t[count + 1];
+
+ loadmodel.edges = edges;
+ loadmodel.numedges = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ edges[i] = new medge_t(bb);
+ }
+ }
+
+ /*
+ =================
+ Mod_LoadTexinfo
+ =================
+ */
+ void Mod_LoadTexinfo(lump_t l)
+ {
+ texinfo_t in;
+ mtexinfo_t[] out;
+ mtexinfo_t step;
+ int i, j, count;
+ int next;
+ String name;
+
+ if ((l.filelen % texinfo_t.SIZE) != 0)
+ ri.Sys_Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / texinfo_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new mtexinfo_t[count];
+ for ( i=0 ; i<count ; i++) {
+ out[i] = new mtexinfo_t();
+ }
+
+ loadmodel.texinfo = out;
+ loadmodel.numtexinfo = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++) {
+
+ in = new texinfo_t(bb);
+ out[i].vecs = in.vecs;
+ out[i].flags = in.flags;
+ next = in.nexttexinfo;
+ if (next > 0)
+ out[i].next = loadmodel.texinfo[next];
+ else
+ out[i].next = null;
+
+ name = "textures/" + in.texture + ".wal";
+
+ out[i].image = GL_FindImage(name, it_wall);
+ if (out[i].image == null) {
+ ri.Con_Printf(Defines.PRINT_ALL, "Couldn't load " + name + '\n');
+ out[i].image = r_notexture;
+ }
+ }
+
+ // count animation frames
+ for (i=0 ; i<count ; i++) {
+ out[i].numframes = 1;
+ for (step = out[i].next ; (step != null) && (step != out[i]) ; step=step.next)
+ out[i].numframes++;
+ }
+ }
+
+ /*
+ ================
+ CalcSurfaceExtents
+
+ Fills in s.texturemins[] and s.extents[]
+ ================
+ */
+ void CalcSurfaceExtents(msurface_t s)
+ {
+ float[] mins = {0, 0};
+ float[] maxs = {0, 0};
+ float val;
+
+ int i, j, e;
+ mvertex_t v;
+ mtexinfo_t tex;
+ int[] bmins = {0, 0};
+ int[] bmaxs = {0, 0};
+
+ mins[0] = mins[1] = 999999;
+ maxs[0] = maxs[1] = -99999;
+
+ tex = s.texinfo;
+
+ for (i=0 ; i<s.numedges ; i++)
+ {
+ e = loadmodel.surfedges[s.firstedge+i];
+ if (e >= 0)
+ v = loadmodel.vertexes[loadmodel.edges[e].v[0]];
+ else
+ v = loadmodel.vertexes[loadmodel.edges[-e].v[1]];
+
+ for (j=0 ; j<2 ; j++)
+ {
+ val = v.position[0] * tex.vecs[j][0] +
+ v.position[1] * tex.vecs[j][1] +
+ v.position[2] * tex.vecs[j][2] +
+ tex.vecs[j][3];
+ if (val < mins[j])
+ mins[j] = val;
+ if (val > maxs[j])
+ maxs[j] = val;
+ }
+ }
+
+ for (i=0 ; i<2 ; i++)
+ {
+ bmins[i] = (int)Math.floor(mins[i]/16);
+ bmaxs[i] = (int)Math.ceil(maxs[i]/16);
+
+ s.texturemins[i] = (short)(bmins[i] * 16);
+ s.extents[i] = (short)((bmaxs[i] - bmins[i]) * 16);
+
+ }
+ }
+
+ /*
+ =================
+ Mod_LoadFaces
+ =================
+ */
+ void Mod_LoadFaces (lump_t l)
+ {
+ qfiles.dface_t in;
+ msurface_t[] out;
+ int i, count, surfnum;
+ int planenum, side;
+ int ti;
+
+ if ((l.filelen % qfiles.dface_t.SIZE) != 0)
+ ri.Sys_Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / qfiles.dface_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new msurface_t[count];
+
+ loadmodel.surfaces = out;
+ loadmodel.numsurfaces = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ currentmodel = loadmodel;
+
+ GL_BeginBuildingLightmaps(loadmodel);
+
+ for ( surfnum=0 ; surfnum<count ; surfnum++)
+ {
+ in = new qfiles.dface_t(bb);
+ out[surfnum] = new msurface_t();
+ out[surfnum].firstedge = in.firstedge;
+ out[surfnum].numedges = in.numedges;
+ out[surfnum].flags = 0;
+ out[surfnum].polys = null;
+
+ planenum = in.planenum;
+ side = in.side;
+ if (side != 0)
+ out[surfnum].flags |= Defines.SURF_PLANEBACK;
+
+ out[surfnum].plane = loadmodel.planes[planenum];
+
+ ti = in.texinfo;
+ if (ti < 0 || ti >= loadmodel.numtexinfo)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: bad texinfo number");
+
+ out[surfnum].texinfo = loadmodel.texinfo[ti];
+
+ CalcSurfaceExtents(out[surfnum]);
+
+ // lighting info
+
+ for (i=0 ; i<Defines.MAXLIGHTMAPS ; i++)
+ out[surfnum].styles[i] = in.styles[i];
+
+ i = in.lightofs;
+ if (i == -1)
+ out[surfnum].samples = null;
+ else {
+ ByteBuffer pointer = ByteBuffer.wrap(loadmodel.lightdata);
+ pointer.position(i);
+ pointer = pointer.slice();
+ pointer.mark();
+ out[surfnum].samples = pointer; // subarray
+ }
+
+ // set the drawing flags
+
+ if ((out[surfnum].texinfo.flags & Defines.SURF_WARP) != 0)
+ {
+ out[surfnum].flags |= Defines.SURF_DRAWTURB;
+ for (i=0 ; i<2 ; i++)
+ {
+ out[surfnum].extents[i] = 16384;
+ out[surfnum].texturemins[i] = -8192;
+ }
+ GL_SubdivideSurface(out[surfnum]); // cut up polygon for warps
+ }
+
+ // create lightmaps and polygons
+ if ((out[surfnum].texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0)
+ GL_CreateSurfaceLightmap(out[surfnum]);
+
+ if ((out[surfnum].texinfo.flags & Defines.SURF_WARP) == 0)
+ GL_BuildPolygonFromSurface(out[surfnum]);
+
+ }
+ GL_EndBuildingLightmaps ();
+ }
+
+
+ /*
+ =================
+ Mod_SetParent
+ =================
+ */
+ void Mod_SetParent(mnode_t node, mnode_t parent)
+ {
+ node.parent = parent;
+ if (node.contents != -1) return;
+ Mod_SetParent(node.children[0], node);
+ Mod_SetParent(node.children[1], node);
+ }
+
+ /*
+ =================
+ Mod_LoadNodes
+ =================
+ */
+ void Mod_LoadNodes(lump_t l)
+ {
+ int i, j, count, p;
+ qfiles.dnode_t in;
+ mnode_t[] out;
+
+ if ((l.filelen % qfiles.dnode_t.SIZE) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / qfiles.dnode_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new mnode_t[count];
+
+ loadmodel.nodes = out;
+ loadmodel.numnodes = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ // initialize the tree array
+ for ( i=0 ; i<count ; i++) out[i] = new mnode_t(); // do first before linking
+
+ // fill and link the nodes
+ for ( i=0 ; i<count ; i++)
+ {
+ in = new qfiles.dnode_t(bb);
+ for (j=0 ; j<3 ; j++)
+ {
+ out[i].mins[j] = in.mins[j];
+ out[i].maxs[j] = in.maxs[j];
+ }
+
+ p = in.planenum;
+ out[i].plane = loadmodel.planes[p];
+
+ out[i].firstsurface = in.firstface;
+ out[i].numsurfaces = in.numfaces;
+ out[i].contents = -1; // differentiate from leafs
+
+ for (j=0 ; j<2 ; j++)
+ {
+ p = in.children[j];
+ if (p >= 0)
+ out[i].children[j] = loadmodel.nodes[p];
+ else
+ out[i].children[j] = loadmodel.leafs[-1 - p]; // mleaf_t extends mnode_t
+ }
+ }
+
+ Mod_SetParent(loadmodel.nodes[0], null); // sets nodes and leafs
+ }
+
+ /*
+ =================
+ Mod_LoadLeafs
+ =================
+ */
+ void Mod_LoadLeafs(lump_t l)
+ {
+ qfiles.dleaf_t in;
+ mleaf_t[] out;
+ int i, j, count, p;
+
+ if ((l.filelen % qfiles.dleaf_t.SIZE) != 0)
+ ri.Sys_Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / qfiles.dleaf_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new mleaf_t[count];
+
+ loadmodel.leafs = out;
+ loadmodel.numleafs = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ in = new qfiles.dleaf_t(bb);
+ out[i] = new mleaf_t();
+ for (j=0 ; j<3 ; j++)
+ {
+ out[i].mins[j] = in.mins[j];
+ out[i].maxs[j] = in.maxs[j];
+
+ }
+
+ out[i].contents = in.contents;
+ out[i].cluster = in.cluster;
+ out[i].area = in.area;
+
+ out[i].setMarkSurface(in.firstleafface, loadmodel.marksurfaces);
+ out[i].nummarksurfaces = in.numleaffaces;
+ }
+ }
+
+
+ /*
+ =================
+ Mod_LoadMarksurfaces
+ =================
+ */
+ void Mod_LoadMarksurfaces(lump_t l)
+ {
+ int i, j, count;
+
+ msurface_t[] out;
+
+ if ((l.filelen % Defines.SIZE_OF_SHORT) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+ count = l.filelen / Defines.SIZE_OF_SHORT;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ out = new msurface_t[count];
+
+ loadmodel.marksurfaces = out;
+ loadmodel.nummarksurfaces = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ j = bb.getShort();
+ if (j < 0 || j >= loadmodel.numsurfaces)
+ ri.Sys_Error(Defines.ERR_DROP, "Mod_ParseMarksurfaces: bad surface number");
+
+ out[i] = loadmodel.surfaces[j];
+ }
+ }
+
+
+ /*
+ =================
+ Mod_LoadSurfedges
+ =================
+ */
+ void Mod_LoadSurfedges(lump_t l)
+ {
+ int i, count;
+ int[] offsets;
+
+ if ( (l.filelen % Defines.SIZE_OF_INT) != 0)
+ ri.Sys_Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / Defines.SIZE_OF_INT;
+ if (count < 1 || count >= Defines.MAX_MAP_SURFEDGES)
+ ri.Sys_Error (Defines.ERR_DROP, "MOD_LoadBmodel: bad surfedges count in " + loadmodel.name + ": " + count);
+
+ offsets = new int[count];
+
+ loadmodel.surfedges = offsets;
+ loadmodel.numsurfedges = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++) offsets[i] = bb.getInt();
+ }
+
+
+ /*
+ =================
+ Mod_LoadPlanes
+ =================
+ */
+ void Mod_LoadPlanes(lump_t l)
+ {
+ int i, j;
+ cplane_t[] out;
+ qfiles.dplane_t in;
+ int count;
+ int bits;
+
+ if ((l.filelen % qfiles.dplane_t.SIZE) != 0)
+ ri.Sys_Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ count = l.filelen / qfiles.dplane_t.SIZE;
+ // out = Hunk_Alloc ( count*2*sizeof(*out));
+ out = new cplane_t[count * 2];
+
+ loadmodel.planes = out;
+ loadmodel.numplanes = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ for ( i=0 ; i<count ; i++)
+ {
+ bits = 0;
+ in = new qfiles.dplane_t(bb);
+ out[i] = new cplane_t();
+ for (j=0 ; j<3 ; j++)
+ {
+ out[i].normal[j] = in.normal[j];
+ if (out[i].normal[j] < 0)
+ bits |= (1<<j);
+ }
+
+ out[i].dist = in.dist;
+ out[i].type = (byte)in.type;
+ out[i].signbits = (byte)bits;
+ }
+ }
+
+ /*
+ =================
+ Mod_LoadBrushModel
+ =================
+ */
+ void Mod_LoadBrushModel(model_t mod, ByteBuffer buffer)
+ {
+ int i;
+ qfiles.dheader_t header;
+ mmodel_t bm;
+
+ loadmodel.type = mod_brush;
+ if (loadmodel != mod_known[0])
+ ri.Sys_Error(Defines.ERR_DROP, "Loaded a brush model after the world");
+
+ header = new qfiles.dheader_t(buffer);
+
+ i = header.version;
+ if (i != Defines.BSPVERSION)
+ ri.Sys_Error (Defines.ERR_DROP, "Mod_LoadBrushModel: " + mod.name + " has wrong version number (" + i + " should be " + Defines.BSPVERSION + ")");
+
+ mod_base = fileBuffer; //(byte *)header;
+
+ // load into heap
+ Mod_LoadVertexes(header.lumps[Defines.LUMP_VERTEXES]); // ok
+ Mod_LoadEdges(header.lumps[Defines.LUMP_EDGES]); // ok
+ Mod_LoadSurfedges(header.lumps[Defines.LUMP_SURFEDGES]); // ok
+ Mod_LoadLighting(header.lumps[Defines.LUMP_LIGHTING]); // ok
+ Mod_LoadPlanes(header.lumps[Defines.LUMP_PLANES]); // ok
+ Mod_LoadTexinfo(header.lumps[Defines.LUMP_TEXINFO]); // ok
+ Mod_LoadFaces(header.lumps[Defines.LUMP_FACES]); // ok
+ Mod_LoadMarksurfaces(header.lumps[Defines.LUMP_LEAFFACES]);
+ Mod_LoadVisibility(header.lumps[Defines.LUMP_VISIBILITY]); // ok
+ Mod_LoadLeafs(header.lumps[Defines.LUMP_LEAFS]); // ok
+ Mod_LoadNodes(header.lumps[Defines.LUMP_NODES]); // ok
+ Mod_LoadSubmodels(header.lumps[Defines.LUMP_MODELS]);
+ mod.numframes = 2; // regular and alternate animation
+
+ //
+ // set up the submodels
+ //
+ model_t starmod;
+
+ for (i=0 ; i<mod.numsubmodels ; i++)
+ {
+
+ bm = mod.submodels[i];
+ starmod = mod_inline[i] = loadmodel.copy();
+
+ starmod.firstmodelsurface = bm.firstface;
+ starmod.nummodelsurfaces = bm.numfaces;
+ starmod.firstnode = bm.headnode;
+ if (starmod.firstnode >= loadmodel.numnodes)
+ ri.Sys_Error(Defines.ERR_DROP, "Inline model " + i + " has bad firstnode");
+
+ Math3D.VectorCopy(bm.maxs, starmod.maxs);
+ Math3D.VectorCopy(bm.mins, starmod.mins);
+ starmod.radius = bm.radius;
+
+ if (i == 0)
+ loadmodel = starmod.copy();
+
+ starmod.numleafs = bm.visleafs;
+ }
+ }
+
+ /*
+ ==============================================================================
+
+ ALIAS MODELS
+
+ ==============================================================================
+ */
+
+ /*
+ =================
+ Mod_LoadAliasModel
+ =================
+ */
+ void Mod_LoadAliasModel (model_t mod, ByteBuffer buffer)
+ {
+ int i, j;
+ qfiles.dmdl_t pheader;
+ qfiles.dstvert_t[] poutst;
+ qfiles.dtriangle_t[] pouttri;
+ qfiles.daliasframe_t[] poutframe;
+ int[] poutcmd;
+
+ pheader = new qfiles.dmdl_t(buffer);
+
+ if (pheader.version != qfiles.ALIAS_VERSION)
+ ri.Sys_Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)",
+ new Vargs(3).add(mod.name).add(pheader.version).add(qfiles.ALIAS_VERSION));
+
+ if (pheader.skinheight > MAX_LBM_HEIGHT)
+ ri.Sys_Error(Defines.ERR_DROP, "model "+ mod.name +" has a skin taller than " + MAX_LBM_HEIGHT);
+
+ if (pheader.num_xyz <= 0)
+ ri.Sys_Error(Defines.ERR_DROP, "model " + mod.name + " has no vertices");
+
+ if (pheader.num_xyz > qfiles.MAX_VERTS)
+ ri.Sys_Error(Defines.ERR_DROP, "model " + mod.name +" has too many vertices");
+
+ if (pheader.num_st <= 0)
+ ri.Sys_Error(Defines.ERR_DROP, "model " + mod.name + " has no st vertices");
+
+ if (pheader.num_tris <= 0)
+ ri.Sys_Error(Defines.ERR_DROP, "model " + mod.name + " has no triangles");
+
+ if (pheader.num_frames <= 0)
+ ri.Sys_Error(Defines.ERR_DROP, "model " + mod.name + " has no frames");
+
+ //
+ // load base s and t vertices (not used in gl version)
+ //
+ poutst = new qfiles.dstvert_t[pheader.num_st];
+ buffer.position(pheader.ofs_st);
+ for (i=0 ; i<pheader.num_st ; i++)
+ {
+ poutst[i] = new qfiles.dstvert_t(buffer);
+ }
+
+ //
+ // load triangle lists
+ //
+ pouttri = new qfiles.dtriangle_t[pheader.num_tris];
+ buffer.position(pheader.ofs_tris);
+ for (i=0 ; i<pheader.num_tris ; i++)
+ {
+ pouttri[i] = new qfiles.dtriangle_t(buffer);
+ }
+
+ //
+ // load the frames
+ //
+ poutframe = new qfiles.daliasframe_t[pheader.num_frames];
+ buffer.position(pheader.ofs_frames);
+ for (i=0 ; i<pheader.num_frames ; i++)
+ {
+ poutframe[i] = new qfiles.daliasframe_t(buffer);
+ // verts are all 8 bit, so no swapping needed
+ poutframe[i].verts = new qfiles.dtrivertx_t[pheader.num_xyz];
+ for (int k=0; k < pheader.num_xyz; k++) {
+ poutframe[i].verts[k] = new qfiles.dtrivertx_t(buffer);
+ }
+ }
+
+ mod.type = mod_alias;
+
+ //
+ // load the glcmds
+ //
+ poutcmd = new int[pheader.num_glcmds];
+ buffer.position(pheader.ofs_glcmds);
+ for (i=0 ; i<pheader.num_glcmds ; i++)
+ poutcmd[i] = buffer.getInt(); // LittleLong (pincmd[i]);
+
+ // register all skins
+ String[] skinNames = new String[pheader.num_skins];
+ byte[] nameBuf = new byte[qfiles.MAX_SKINNAME];
+ buffer.position(pheader.ofs_skins);
+ for (i=0 ; i<pheader.num_skins ; i++)
+ {
+ buffer.get(nameBuf);
+ skinNames[i] = new String(nameBuf).trim();
+ mod.skins[i] = GL_FindImage(skinNames[i], it_skin);
+ }
+
+ // set the model arrays
+ pheader.skinNames = skinNames; // skin names
+ pheader.stVerts = poutst; // textur koordinaten
+ pheader.triAngles = pouttri; // dreiecke
+ pheader.glCmds = poutcmd; // STRIP or FAN
+ pheader.aliasFrames = poutframe; // frames mit vertex array
+
+ mod.extradata = pheader;
+
+ mod.mins[0] = -32;
+ mod.mins[1] = -32;
+ mod.mins[2] = -32;
+ mod.maxs[0] = 32;
+ mod.maxs[1] = 32;
+ mod.maxs[2] = 32;
+
+ precompileGLCmds(pheader);
+ }
+
+ /*
+ ==============================================================================
+
+ SPRITE MODELS
+
+ ==============================================================================
+ */
+
+ /*
+ =================
+ Mod_LoadSpriteModel
+ =================
+ */
+ void Mod_LoadSpriteModel(model_t mod, ByteBuffer buffer)
+ {
+ qfiles.dsprite_t sprout = new qfiles.dsprite_t(buffer);
+
+ if (sprout.version != qfiles.SPRITE_VERSION)
+ ri.Sys_Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)",
+ new Vargs(3).add(mod.name).add(sprout.version).add(qfiles.SPRITE_VERSION));
+
+ if (sprout.numframes > qfiles.MAX_MD2SKINS)
+ ri.Sys_Error(Defines.ERR_DROP, "%s has too many frames (%i > %i)",
+ new Vargs(3).add(mod.name).add(sprout.numframes).add(qfiles.MAX_MD2SKINS));
+
+ for (int i=0 ; i<sprout.numframes ; i++)
+ {
+ mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite);
+ }
+
+ mod.type = mod_sprite;
+ mod.extradata = sprout;
+ }
+
+// =============================================================================
+
+ /*
+ @@@@@@@@@@@@@@@@@@@@@
+ R_BeginRegistration
+
+ Specifies the model that will be used as the world
+ @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected void R_BeginRegistration(String model)
+ {
+ resetModelArrays();
+ resetPolygonArrays();
+
+ cvar_t flushmap;
+
+ registration_sequence++;
+ r_oldviewcluster = -1; // force markleafs
+
+ String fullname = "maps/" + model + ".bsp";
+
+ // explicitly free the old map if different
+ // this guarantees that mod_known[0] is the world map
+ flushmap = ri.Cvar_Get("flushmap", "0", 0);
+ if ( !mod_known[0].name.equals(fullname) || flushmap.value != 0.0f)
+ Mod_Free(mod_known[0]);
+ r_worldmodel = Mod_ForName(fullname, true);
+
+ r_viewcluster = -1;
+ }
+
+
+ /*
+ @@@@@@@@@@@@@@@@@@@@@
+ R_RegisterModel
+
+ @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected model_t R_RegisterModel(String name)
+ {
+ model_t mod = null;
+ int i;
+ qfiles.dsprite_t sprout;
+ qfiles.dmdl_t pheader;
+
+ mod = Mod_ForName(name, false);
+ if (mod != null)
+ {
+ mod.registration_sequence = registration_sequence;
+
+ // register any images used by the models
+ if (mod.type == mod_sprite)
+ {
+ sprout = (qfiles.dsprite_t)mod.extradata;
+ for (i=0 ; i<sprout.numframes ; i++)
+ mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite);
+ }
+ else if (mod.type == mod_alias)
+ {
+ pheader = (qfiles.dmdl_t)mod.extradata;
+ for (i=0 ; i<pheader.num_skins ; i++)
+ mod.skins[i] = GL_FindImage(pheader.skinNames[i], it_skin);
+ // PGM
+ mod.numframes = pheader.num_frames;
+ // PGM
+ }
+ else if (mod.type == mod_brush)
+ {
+ for (i=0 ; i<mod.numtexinfo ; i++)
+ mod.texinfo[i].image.registration_sequence = registration_sequence;
+ }
+ }
+ return mod;
+ }
+
+
+ /*
+ @@@@@@@@@@@@@@@@@@@@@
+ R_EndRegistration
+
+ @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected void R_EndRegistration()
+ {
+ model_t mod;
+
+ for (int i=0; i<mod_numknown ; i++)
+ {
+ mod = mod_known[i];
+ if (mod.name == "")
+ continue;
+ if (mod.registration_sequence != registration_sequence)
+ { // don't need this model
+ Mod_Free(mod);
+ } else {
+ // precompile AliasModels
+ if (mod.type == mod_alias)
+ precompileGLCmds((qfiles.dmdl_t)mod.extradata);
+ }
+ }
+ GL_FreeUnusedImages();
+
+ //modelMemoryUsage();
+ }
+
+
+// =============================================================================
+
+
+ /*
+ ================
+ Mod_Free
+ ================
+ */
+ void Mod_Free (model_t mod)
+ {
+ mod.clear();
+ }
+
+ /*
+ ================
+ Mod_FreeAll
+ ================
+ */
+ void Mod_FreeAll()
+ {
+ for (int i=0 ; i<mod_numknown ; i++)
+ {
+ if (mod_known[i].extradata != null)
+ Mod_Free(mod_known[i]);
+ }
+ }
+
+ /*
+ * new functions for vertex array handling
+ */
+ static final int MODEL_BUFFER_SIZE = 50000;
+ static FloatBuffer globalModelTextureCoordBuf = BufferUtils.newFloatBuffer(MODEL_BUFFER_SIZE * 2);
+ static IntBuffer globalModelVertexIndexBuf = BufferUtils.newIntBuffer(MODEL_BUFFER_SIZE);
+
+ void precompileGLCmds(qfiles.dmdl_t model) {
+ model.textureCoordBuf = globalModelTextureCoordBuf.slice();
+ model.vertexIndexBuf = globalModelVertexIndexBuf.slice();
+ Vector tmp = new Vector();
+
+ int count = 0;
+ int[] order = model.glCmds;
+ int orderIndex = 0;
+ while (true)
+ {
+ // get the vertex count and primitive type
+ count = order[orderIndex++];
+ if (count == 0)
+ break; // done
+
+ tmp.addElement(new Integer(count));
+
+ if (count < 0)
+ {
+ count = -count;
+ //gl.glBegin (GL.GL_TRIANGLE_FAN);
+ }
+ else
+ {
+ //gl.glBegin (GL.GL_TRIANGLE_STRIP);
+ }
+
+ do {
+ // texture coordinates come from the draw list
+ globalModelTextureCoordBuf.put(Float.intBitsToFloat(order[orderIndex + 0]));
+ globalModelTextureCoordBuf.put(Float.intBitsToFloat(order[orderIndex + 1]));
+ globalModelVertexIndexBuf.put(order[orderIndex + 2]);
+
+ orderIndex += 3;
+ } while (--count != 0);
+ }
+
+ int size = tmp.size();
+
+ model.counts = new int[size];
+ model.indexElements = new IntBuffer[size];
+
+ count = 0;
+ int pos = 0;
+ for (int i = 0; i < model.counts.length; i++) {
+ count = ((Integer)tmp.get(i)).intValue();
+ model.counts[i] = count;
+
+ count = (count < 0) ? -count : count;
+ model.vertexIndexBuf.position(pos);
+ model.indexElements[i] = model.vertexIndexBuf.slice();
+ pos += count;
+ }
+ }
+
+ static void resetModelArrays() {
+ globalModelTextureCoordBuf.rewind();
+ globalModelVertexIndexBuf.rewind();
+ }
+
+ static void modelMemoryUsage() {
+ System.out.println("AliasModels: globalVertexBuffer size " + globalModelVertexIndexBuf.position());
+ }
+}
diff --git a/src/jake2/render/fastjogl/Surf.java b/src/jake2/render/fastjogl/Surf.java
new file mode 100644
index 0000000..c7e7bc0
--- /dev/null
+++ b/src/jake2/render/fastjogl/Surf.java
@@ -0,0 +1,1464 @@
+/*
+ * Surf.java
+ * Copyright (C) 2003
+ *
+ * $Id: Surf.java,v 1.1 2004-07-09 06:50:48 hzi 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.fastjogl;
+
+import jake2.Defines;
+import jake2.client.*;
+import jake2.game.cplane_t;
+import jake2.render.*;
+import jake2.util.Lib;
+import jake2.util.Math3D;
+
+import java.nio.*;
+import java.util.Arrays;
+
+import net.java.games.jogl.GL;
+import net.java.games.jogl.util.BufferUtils;
+
+/**
+ * Surf
+ *
+ * @author cwei
+ */
+public abstract class Surf extends Draw {
+
+ // GL_RSURF.C: surface-related refresh code
+ float[] modelorg = {0, 0, 0}; // relative to viewpoint
+
+ msurface_t r_alpha_surfaces;
+
+ static final int DYNAMIC_LIGHT_WIDTH = 128;
+ static final int DYNAMIC_LIGHT_HEIGHT = 128;
+
+ static final int LIGHTMAP_BYTES = 4;
+
+ static final int BLOCK_WIDTH = 128;
+ static final int BLOCK_HEIGHT = 128;
+
+ static final int MAX_LIGHTMAPS = 128;
+
+ int c_visible_lightmaps;
+ int c_visible_textures;
+
+ static final int GL_LIGHTMAP_FORMAT = GL.GL_RGBA;
+
+ static class gllightmapstate_t
+ {
+ int internal_format;
+ int current_lightmap_texture;
+
+ msurface_t[] lightmap_surfaces = new msurface_t[MAX_LIGHTMAPS];
+ int[] allocated = new int[BLOCK_WIDTH];
+
+ // the lightmap texture data needs to be kept in
+ // main memory so texsubimage can update properly
+ //byte[] lightmap_buffer = new byte[4 * BLOCK_WIDTH * BLOCK_HEIGHT];
+ IntBuffer lightmap_buffer = Lib.newIntBuffer(BLOCK_WIDTH * BLOCK_HEIGHT, ByteOrder.LITTLE_ENDIAN);
+
+ public gllightmapstate_t() {
+ for (int i = 0; i < MAX_LIGHTMAPS; i++)
+ lightmap_surfaces[i] = new msurface_t();
+ }
+
+ public void clearLightmapSurfaces() {
+ for (int i = 0; i < MAX_LIGHTMAPS; i++)
+ // TODO lightmap_surfaces[i].clear();
+ lightmap_surfaces[i] = new msurface_t();
+ }
+
+ }
+
+ gllightmapstate_t gl_lms = new gllightmapstate_t();
+
+ // Model.java
+ abstract byte[] Mod_ClusterPVS(int cluster, model_t model);
+ // Warp.java
+ abstract void R_DrawSkyBox();
+ abstract void R_AddSkySurface(msurface_t surface);
+ abstract void R_ClearSkyBox();
+ abstract void EmitWaterPolys(msurface_t fa);
+ // Light.java
+ abstract void R_MarkLights (dlight_t light, int bit, mnode_t node);
+ abstract void R_SetCacheState( msurface_t surf );
+ abstract void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride);
+
+ /*
+ =============================================================
+
+ BRUSH MODELS
+
+ =============================================================
+ */
+
+ /*
+ ===============
+ R_TextureAnimation
+
+ Returns the proper texture for a given time and base texture
+ ===============
+ */
+ image_t R_TextureAnimation(mtexinfo_t tex)
+ {
+ int c;
+
+ if (tex.next == null)
+ return tex.image;
+
+ c = currententity.frame % tex.numframes;
+ while (c != 0)
+ {
+ tex = tex.next;
+ c--;
+ }
+
+ return tex.image;
+ }
+
+ /*
+ ================
+ DrawGLPoly
+ ================
+ */
+ void DrawGLPoly(glpoly_t p)
+ {
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+
+ // ============
+ // PGM
+ /*
+ ================
+ DrawGLFlowingPoly -- version of DrawGLPoly that handles scrolling texture
+ ================
+ */
+ void DrawGLFlowingPoly(glpoly_t p)
+ {
+ int i;
+ float scroll;
+
+ scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) );
+ if(scroll == 0.0f)
+ scroll = -64.0f;
+
+ FloatBuffer texCoord = globalPolygonInterleavedBuf;
+ float[][] v = p.verts;
+ int index = p.pos * POLYGON_STRIDE;
+ for (i=0 ; i<p.numverts ; i++) {
+ texCoord.put(index, v[i][3] + scroll);
+ index += POLYGON_STRIDE;
+ }
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+ // PGM
+ // ============
+
+ /*
+ ** R_DrawTriangleOutlines
+ */
+ void R_DrawTriangleOutlines()
+ {
+ int i, j;
+ glpoly_t p;
+
+ if (gl_showtris.value == 0)
+ return;
+
+ gl.glDisable (GL.GL_TEXTURE_2D);
+ gl.glDisable (GL.GL_DEPTH_TEST);
+ gl.glColor4f (1,1,1,1);
+
+ for (i=0 ; i<MAX_LIGHTMAPS ; i++)
+ {
+ msurface_t surf;
+
+ for ( surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain )
+ {
+ p = surf.polys;
+ for ( ; p != null ; p=p.chain)
+ {
+ for (j=2 ; j<p.numverts ; j++ )
+ {
+ gl.glBegin (GL.GL_LINE_STRIP);
+ gl.glVertex3fv (p.verts[0]);
+ gl.glVertex3fv (p.verts[j-1]);
+ gl.glVertex3fv (p.verts[j]);
+ gl.glVertex3fv (p.verts[0]);
+ gl.glEnd ();
+ }
+ }
+ }
+ }
+
+ gl.glEnable (GL.GL_DEPTH_TEST);
+ gl.glEnable (GL.GL_TEXTURE_2D);
+ }
+
+ private IntBuffer temp2 = Lib.newIntBuffer(34 * 34, ByteOrder.LITTLE_ENDIAN);
+
+ /*
+ ================
+ R_RenderBrushPoly
+ ================
+ */
+ void R_RenderBrushPoly(msurface_t fa)
+ {
+ int maps;
+ image_t image;
+ boolean is_dynamic = false;
+
+ c_brush_polys++;
+
+ image = R_TextureAnimation(fa.texinfo);
+
+ if ((fa.flags & Defines.SURF_DRAWTURB) != 0)
+ {
+ GL_Bind( image.texnum );
+
+ // warp texture, no lightmaps
+ GL_TexEnv( GL.GL_MODULATE );
+ gl.glColor4f( gl_state.inverse_intensity,
+ gl_state.inverse_intensity,
+ gl_state.inverse_intensity,
+ 1.0F );
+ EmitWaterPolys (fa);
+ GL_TexEnv( GL.GL_REPLACE );
+
+ return;
+ }
+ else
+ {
+ GL_Bind( image.texnum );
+ GL_TexEnv( GL.GL_REPLACE );
+ }
+
+ // ======
+ // PGM
+ if((fa.texinfo.flags & Defines.SURF_FLOWING) != 0)
+ DrawGLFlowingPoly(fa.polys);
+ else
+ DrawGLPoly (fa.polys);
+ // PGM
+ // ======
+
+ // ersetzt goto
+ boolean gotoDynamic = false;
+ /*
+ ** check for lightmap modification
+ */
+ for ( maps = 0; maps < Defines.MAXLIGHTMAPS && fa.styles[maps] != (byte)255; maps++ )
+ {
+ if ( r_newrefdef.lightstyles[fa.styles[maps] & 0xFF].white != fa.cached_light[maps] ) {
+ gotoDynamic = true;
+ break;
+ }
+ }
+
+ // this is a hack from cwei
+ if (maps == 4) maps--;
+
+ // dynamic this frame or dynamic previously
+ if ( gotoDynamic || ( fa.dlightframe == r_framecount ) )
+ {
+ // label dynamic:
+ if ( gl_dynamic.value != 0 )
+ {
+ if (( fa.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP ) ) == 0)
+ {
+ is_dynamic = true;
+ }
+ }
+ }
+
+ if ( is_dynamic )
+ {
+ if ( ( (fa.styles[maps] & 0xFF) >= 32 || fa.styles[maps] == 0 ) && ( fa.dlightframe != r_framecount ) )
+ {
+ // ist ersetzt durch temp2: unsigned temp[34*34];
+ int smax, tmax;
+
+ smax = (fa.extents[0]>>4)+1;
+ tmax = (fa.extents[1]>>4)+1;
+
+ R_BuildLightMap( fa, temp2, smax);
+ R_SetCacheState( fa );
+
+ GL_Bind( gl_state.lightmap_textures + fa.lightmaptexturenum );
+
+ gl.glTexSubImage2D( GL.GL_TEXTURE_2D, 0,
+ fa.light_s, fa.light_t,
+ smax, tmax,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE, temp2 );
+
+ fa.lightmapchain = gl_lms.lightmap_surfaces[fa.lightmaptexturenum];
+ gl_lms.lightmap_surfaces[fa.lightmaptexturenum] = fa;
+ }
+ else
+ {
+ fa.lightmapchain = gl_lms.lightmap_surfaces[0];
+ gl_lms.lightmap_surfaces[0] = fa;
+ }
+ }
+ else
+ {
+ fa.lightmapchain = gl_lms.lightmap_surfaces[fa.lightmaptexturenum];
+ gl_lms.lightmap_surfaces[fa.lightmaptexturenum] = fa;
+ }
+ }
+
+
+ /*
+ ================
+ R_DrawAlphaSurfaces
+
+ Draw water surfaces and windows.
+ The BSP tree is waled front to back, so unwinding the chain
+ of alpha_surfaces will draw back to front, giving proper ordering.
+ ================
+ */
+ void R_DrawAlphaSurfaces()
+ {
+ msurface_t s;
+ float intens;
+
+ //
+ // go back to the world matrix
+ //
+ gl.glLoadMatrixf(r_world_matrix);
+
+ gl.glEnable (GL.GL_BLEND);
+ GL_TexEnv(GL.GL_MODULATE );
+
+
+ // the textures are prescaled up for a better lighting range,
+ // so scale it back down
+ intens = gl_state.inverse_intensity;
+
+ gl.glInterleavedArrays(GL.GL_T2F_V3F, POLYGON_BYTE_STRIDE, globalPolygonInterleavedBuf);
+
+ for (s=r_alpha_surfaces ; s != null ; s=s.texturechain)
+ {
+ GL_Bind(s.texinfo.image.texnum);
+ c_brush_polys++;
+ if ((s.texinfo.flags & Defines.SURF_TRANS33) != 0)
+ gl.glColor4f (intens, intens, intens, 0.33f);
+ else if ((s.texinfo.flags & Defines.SURF_TRANS66) != 0)
+ gl.glColor4f (intens, intens, intens, 0.66f);
+ else
+ gl.glColor4f (intens,intens,intens,1);
+ if ((s.flags & Defines.SURF_DRAWTURB) != 0)
+ EmitWaterPolys(s);
+ else if((s.texinfo.flags & Defines.SURF_FLOWING) != 0) // PGM 9/16/98
+ DrawGLFlowingPoly(s.polys); // PGM
+ else
+ DrawGLPoly(s.polys);
+ }
+
+ GL_TexEnv( GL.GL_REPLACE );
+ gl.glColor4f (1,1,1,1);
+ gl.glDisable (GL.GL_BLEND);
+
+ r_alpha_surfaces = null;
+ }
+
+ /*
+ ================
+ DrawTextureChains
+ ================
+ */
+ void DrawTextureChains()
+ {
+ int i;
+ msurface_t s;
+ image_t image;
+
+ c_visible_textures = 0;
+
+ for (i = 0; i < numgltextures ; i++)
+ {
+ image = gltextures[i];
+
+ if (image.registration_sequence == 0)
+ continue;
+ if (image.texturechain == null)
+ continue;
+ c_visible_textures++;
+
+ for ( s = image.texturechain; s != null ; s=s.texturechain)
+ {
+ if ( ( s.flags & Defines.SURF_DRAWTURB) == 0 )
+ R_RenderBrushPoly(s);
+ }
+ }
+
+ GL_EnableMultitexture( false );
+ for (i = 0; i < numgltextures ; i++)
+ {
+ image = gltextures[i];
+
+ if (image.registration_sequence == 0)
+ continue;
+ s = image.texturechain;
+ if (s == null)
+ continue;
+
+ for ( ; s != null ; s=s.texturechain)
+ {
+ if ( (s.flags & Defines.SURF_DRAWTURB) != 0 )
+ R_RenderBrushPoly(s);
+ }
+
+ image.texturechain = null;
+ }
+
+ GL_TexEnv( GL.GL_REPLACE );
+ }
+
+ // direct buffer
+ private IntBuffer temp = Lib.newIntBuffer(128 * 128, ByteOrder.LITTLE_ENDIAN);
+
+ void GL_RenderLightmappedPoly( msurface_t surf )
+ {
+ int i, nv = surf.polys.numverts;
+ int map = 0;
+ int index;
+ float[][] v;
+ FloatBuffer texCoord = globalPolygonInterleavedBuf;
+ image_t image = R_TextureAnimation( surf.texinfo );
+ boolean is_dynamic = false;
+ int lmtex = surf.lightmaptexturenum;
+ glpoly_t p;
+
+ // ersetzt goto
+ boolean gotoDynamic = false;
+
+ for ( map = 0; map < Defines.MAXLIGHTMAPS && (surf.styles[map] != (byte)255); map++ )
+ {
+ if ( r_newrefdef.lightstyles[surf.styles[map] & 0xFF].white != surf.cached_light[map] ) {
+ gotoDynamic = true;
+ break;
+ }
+ }
+
+ // this is a hack from cwei
+ if (map == 4) map--;
+
+ // dynamic this frame or dynamic previously
+ if ( gotoDynamic || ( surf.dlightframe == r_framecount ) )
+ {
+ // label dynamic:
+ if ( gl_dynamic.value != 0 )
+ {
+ if ( (surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP )) == 0 )
+ {
+ is_dynamic = true;
+ }
+ }
+ }
+
+ if ( is_dynamic )
+ {
+ // ist raus gezogen worden int[] temp = new int[128*128];
+ int smax, tmax;
+
+ if ( ( (surf.styles[map] & 0xFF) >= 32 || surf.styles[map] == 0 ) && ( surf.dlightframe != r_framecount ) )
+ {
+ smax = (surf.extents[0]>>4)+1;
+ tmax = (surf.extents[1]>>4)+1;
+
+ R_BuildLightMap( surf, temp, smax);
+ R_SetCacheState( surf );
+
+ GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + surf.lightmaptexturenum );
+
+ lmtex = surf.lightmaptexturenum;
+
+ gl.glTexSubImage2D( GL.GL_TEXTURE_2D, 0,
+ surf.light_s, surf.light_t,
+ smax, tmax,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE, temp );
+
+ }
+ else
+ {
+ smax = (surf.extents[0]>>4)+1;
+ tmax = (surf.extents[1]>>4)+1;
+
+ R_BuildLightMap( surf, temp, smax);
+
+ GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + 0 );
+
+ lmtex = 0;
+
+ gl.glTexSubImage2D( GL.GL_TEXTURE_2D, 0,
+ surf.light_s, surf.light_t,
+ smax, tmax,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE, temp );
+
+ }
+
+ c_brush_polys++;
+
+ GL_MBind( GL_TEXTURE0, image.texnum );
+ GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + lmtex );
+
+ // ==========
+ // PGM
+ if ((surf.texinfo.flags & Defines.SURF_FLOWING) != 0)
+ {
+ float scroll;
+
+ scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) );
+ if(scroll == 0.0f)
+ scroll = -64.0f;
+
+ for ( p = surf.polys; p != null; p = p.chain )
+ {
+ v = p.verts;
+ index = p.pos * POLYGON_STRIDE;
+ for (i=0 ; i<p.numverts ; i++) {
+ texCoord.put(index, v[i][3] + scroll);
+ index += POLYGON_STRIDE;
+ }
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+ }
+ else
+ {
+ for ( p = surf.polys; p != null; p = p.chain )
+ {
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+ }
+ // PGM
+ // ==========
+ }
+ else
+ {
+ c_brush_polys++;
+
+ GL_MBind( GL_TEXTURE0, image.texnum );
+ GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + lmtex);
+
+ // ==========
+ // PGM
+ if ((surf.texinfo.flags & Defines.SURF_FLOWING) != 0)
+ {
+ float scroll;
+
+ scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) );
+ if(scroll == 0.0)
+ scroll = -64.0f;
+
+ for ( p = surf.polys; p != null; p = p.chain )
+ {
+ v = p.verts;
+ index = p.pos * POLYGON_STRIDE;
+ for (i=0 ; i<p.numverts ; i++) {
+ texCoord.put(index, v[i][3] + scroll);
+ index += POLYGON_STRIDE;
+ }
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+ }
+ else
+ {
+ // PGM
+ // ==========
+ for ( p = surf.polys; p != null; p = p.chain )
+ {
+ gl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ }
+
+ // ==========
+ // PGM
+ }
+ // PGM
+ // ==========
+ }
+ }
+
+ /*
+ =================
+ R_DrawInlineBModel
+ =================
+ */
+ void R_DrawInlineBModel()
+ {
+ int i, k;
+ cplane_t pplane;
+ float dot;
+ msurface_t psurf;
+ dlight_t lt;
+
+ // calculate dynamic lighting for bmodel
+ if ( gl_flashblend.value == 0 )
+ {
+ for (k=0 ; k<r_newrefdef.num_dlights ; k++)
+ {
+ lt = r_newrefdef.dlights[k];
+ R_MarkLights(lt, 1<<k, currentmodel.nodes[currentmodel.firstnode]);
+ }
+ }
+
+ // psurf = &currentmodel->surfaces[currentmodel->firstmodelsurface];
+ int psurfp = currentmodel.firstmodelsurface;
+ msurface_t[] surfaces;
+ surfaces = currentmodel.surfaces;
+ //psurf = surfaces[psurfp];
+
+ if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 )
+ {
+ gl.glEnable (GL.GL_BLEND);
+ gl.glColor4f (1,1,1,0.25f);
+ GL_TexEnv( GL.GL_MODULATE );
+ }
+
+ //
+ // draw texture
+ //
+ for (i=0 ; i<currentmodel.nummodelsurfaces ; i++)
+ {
+ psurf = surfaces[psurfp++];
+ // find which side of the node we are on
+ pplane = psurf.plane;
+
+ dot = Math3D.DotProduct(modelorg, pplane.normal) - pplane.dist;
+
+ // draw the polygon
+ if (((psurf.flags & Defines.SURF_PLANEBACK) != 0 && (dot < -BACKFACE_EPSILON)) ||
+ ((psurf.flags & Defines.SURF_PLANEBACK) == 0 && (dot > BACKFACE_EPSILON)))
+ {
+ if ((psurf.texinfo.flags & (Defines.SURF_TRANS33 | Defines.SURF_TRANS66)) != 0 )
+ { // add to the translucent chain
+ psurf.texturechain = r_alpha_surfaces;
+ r_alpha_surfaces = psurf;
+ }
+ else if ( (psurf.flags & Defines.SURF_DRAWTURB) == 0 )
+ {
+ GL_RenderLightmappedPoly( psurf );
+ }
+ else
+ {
+ GL_EnableMultitexture( false );
+ R_RenderBrushPoly( psurf );
+ GL_EnableMultitexture( true );
+ }
+ }
+ }
+
+ if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 ) {
+ gl.glDisable (GL.GL_BLEND);
+ gl.glColor4f (1,1,1,1);
+ GL_TexEnv( GL.GL_REPLACE );
+ }
+ }
+
+ /*
+ =================
+ R_DrawBrushModel
+ =================
+ */
+ void R_DrawBrushModel(entity_t e)
+ {
+ float[] mins = {0, 0, 0};
+ float[] maxs = {0, 0, 0};
+ int i;
+ boolean rotated;
+
+ if (currentmodel.nummodelsurfaces == 0)
+ return;
+
+ currententity = e;
+ gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
+
+ if (e.angles[0] != 0 || e.angles[1] != 0 || e.angles[2] != 0)
+ {
+ rotated = true;
+ for (i=0 ; i<3 ; i++)
+ {
+ mins[i] = e.origin[i] - currentmodel.radius;
+ maxs[i] = e.origin[i] + currentmodel.radius;
+ }
+ }
+ else
+ {
+ rotated = false;
+ Math3D.VectorAdd(e.origin, currentmodel.mins, mins);
+ Math3D.VectorAdd(e.origin, currentmodel.maxs, maxs);
+ }
+
+ if (R_CullBox(mins, maxs)) return;
+
+ gl.glColor3f (1,1,1);
+
+ // memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
+
+ // TODO wird beim multitexturing nicht gebraucht
+ //gl_lms.clearLightmapSurfaces();
+
+ Math3D.VectorSubtract (r_newrefdef.vieworg, e.origin, modelorg);
+ if (rotated)
+ {
+ float[] temp = {0, 0, 0};
+ float[] forward = {0, 0, 0};
+ float[] right = {0, 0, 0};
+ float[] up = {0, 0, 0};
+
+ Math3D.VectorCopy (modelorg, temp);
+ Math3D.AngleVectors (e.angles, forward, right, up);
+ modelorg[0] = Math3D.DotProduct (temp, forward);
+ modelorg[1] = -Math3D.DotProduct (temp, right);
+ modelorg[2] = Math3D.DotProduct (temp, up);
+ }
+
+ gl.glPushMatrix();
+
+ e.angles[0] = -e.angles[0]; // stupid quake bug
+ e.angles[2] = -e.angles[2]; // stupid quake bug
+ R_RotateForEntity(e);
+ e.angles[0] = -e.angles[0]; // stupid quake bug
+ e.angles[2] = -e.angles[2]; // stupid quake bug
+
+ GL_EnableMultitexture( true );
+ GL_SelectTexture(GL_TEXTURE0);
+ GL_TexEnv( GL.GL_REPLACE );
+ gl.glInterleavedArrays(GL.GL_T2F_V3F, POLYGON_BYTE_STRIDE, globalPolygonInterleavedBuf);
+ GL_SelectTexture(GL_TEXTURE1);
+ GL_TexEnv( GL.GL_MODULATE );
+ gl.glTexCoordPointer(2, GL.GL_FLOAT, POLYGON_BYTE_STRIDE, globalPolygonTexCoord1Buf);
+ gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
+
+ R_DrawInlineBModel();
+
+ gl.glClientActiveTextureARB(GL_TEXTURE1);
+ gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
+
+ GL_EnableMultitexture( false );
+
+ gl.glPopMatrix();
+ }
+
+ /*
+ =============================================================
+
+ WORLD MODEL
+
+ =============================================================
+ */
+
+ /*
+ ================
+ R_RecursiveWorldNode
+ ================
+ */
+ void R_RecursiveWorldNode (mnode_t node)
+ {
+ int c, side, sidebit;
+ cplane_t plane;
+ msurface_t surf;
+ msurface_t mark;
+ mleaf_t pleaf;
+ float dot = 0;
+ image_t image;
+
+ if (node.contents == Defines.CONTENTS_SOLID)
+ return; // solid
+
+ if (node.visframe != r_visframecount)
+ return;
+
+ if (R_CullBox(node.mins, node.maxs))
+ return;
+
+ // if a leaf node, draw stuff
+ if (node.contents != -1)
+ {
+ pleaf = (mleaf_t)node;
+
+ // check for door connected areas
+ if (r_newrefdef.areabits != null)
+ {
+ if ( ((r_newrefdef.areabits[pleaf.area >> 3] & 0xFF) & (1 << (pleaf.area & 7)) ) == 0 )
+ return; // not visible
+ }
+
+ int markp = 0;
+
+ mark = pleaf.getMarkSurface(markp); // first marked surface
+ c = pleaf.nummarksurfaces;
+
+ if (c != 0)
+ {
+ do
+ {
+ mark.visframe = r_framecount;
+ mark = pleaf.getMarkSurface(++markp); // next surface
+ } while (--c != 0);
+ }
+
+ return;
+ }
+
+ // node is just a decision point, so go down the apropriate sides
+
+ // find which side of the node we are on
+ plane = node.plane;
+
+ switch (plane.type)
+ {
+ case Defines.PLANE_X:
+ dot = modelorg[0] - plane.dist;
+ break;
+ case Defines.PLANE_Y:
+ dot = modelorg[1] - plane.dist;
+ break;
+ case Defines.PLANE_Z:
+ dot = modelorg[2] - plane.dist;
+ break;
+ default:
+ dot = Math3D.DotProduct(modelorg, plane.normal) - plane.dist;
+ break;
+ }
+
+ if (dot >= 0.0f)
+ {
+ side = 0;
+ sidebit = 0;
+ }
+ else
+ {
+ side = 1;
+ sidebit = Defines.SURF_PLANEBACK;
+ }
+
+ // recurse down the children, front side first
+ R_RecursiveWorldNode(node.children[side]);
+
+ // draw stuff
+ //for ( c = node.numsurfaces, surf = r_worldmodel.surfaces[node.firstsurface]; c != 0 ; c--, surf++)
+ for ( c = 0; c < node.numsurfaces; c++)
+ {
+ surf = r_worldmodel.surfaces[node.firstsurface + c];
+ if (surf.visframe != r_framecount)
+ continue;
+
+ if ( (surf.flags & Defines.SURF_PLANEBACK) != sidebit )
+ continue; // wrong side
+
+ if ((surf.texinfo.flags & Defines.SURF_SKY) != 0)
+ { // just adds to visible sky bounds
+ R_AddSkySurface(surf);
+ }
+ else if ((surf.texinfo.flags & (Defines.SURF_TRANS33 | Defines.SURF_TRANS66)) != 0)
+ { // add to the translucent chain
+ surf.texturechain = r_alpha_surfaces;
+ r_alpha_surfaces = surf;
+ }
+ else
+ {
+ if ( ( surf.flags & Defines.SURF_DRAWTURB) == 0 )
+ {
+ GL_RenderLightmappedPoly( surf );
+ }
+ else
+ {
+ // the polygon is visible, so add it to the texture
+ // sorted chain
+ // FIXME: this is a hack for animation
+ image = R_TextureAnimation(surf.texinfo);
+ surf.texturechain = image.texturechain;
+ image.texturechain = surf;
+ }
+ }
+ }
+
+ // recurse down the back side
+ R_RecursiveWorldNode(node.children[1 - side]);
+ }
+
+
+ /*
+ =============
+ R_DrawWorld
+ =============
+ */
+ void R_DrawWorld()
+ {
+ entity_t ent = new entity_t();
+
+ if (r_drawworld.value == 0)
+ return;
+
+ if ( (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0 )
+ return;
+
+ currentmodel = r_worldmodel;
+
+ Math3D.VectorCopy(r_newrefdef.vieworg, modelorg);
+
+ // auto cycle the world frame for texture animation
+ // memset (&ent, 0, sizeof(ent));
+ ent.frame = (int)(r_newrefdef.time*2);
+ currententity = ent;
+
+ gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
+
+ gl.glColor3f (1,1,1);
+ // memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
+ // TODO wird bei multitexture nicht gebraucht
+ //gl_lms.clearLightmapSurfaces();
+
+ R_ClearSkyBox();
+
+ GL_EnableMultitexture( true );
+
+ GL_SelectTexture( GL_TEXTURE0);
+ GL_TexEnv( GL.GL_REPLACE );
+ gl.glInterleavedArrays(GL.GL_T2F_V3F, POLYGON_BYTE_STRIDE, globalPolygonInterleavedBuf);
+ GL_SelectTexture( GL_TEXTURE1);
+ gl.glTexCoordPointer(2, GL.GL_FLOAT, POLYGON_BYTE_STRIDE, globalPolygonTexCoord1Buf);
+ gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
+
+ if ( gl_lightmap.value != 0)
+ GL_TexEnv( GL.GL_REPLACE );
+ else
+ GL_TexEnv( GL.GL_MODULATE );
+
+ R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node
+
+ gl.glClientActiveTextureARB(GL_TEXTURE1);
+ gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
+
+ GL_EnableMultitexture( false );
+
+ DrawTextureChains();
+ R_DrawSkyBox();
+ R_DrawTriangleOutlines();
+ }
+
+ byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8];
+
+ /*
+ ===============
+ R_MarkLeaves
+
+ Mark the leaves and nodes that are in the PVS for the current
+ cluster
+ ===============
+ */
+ void R_MarkLeaves()
+ {
+ byte[] vis;
+ //byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8];
+
+ Arrays.fill(fatvis, (byte)0);
+
+ mnode_t node;
+ int i, c;
+ mleaf_t leaf;
+ int cluster;
+
+ if (r_oldviewcluster == r_viewcluster && r_oldviewcluster2 == r_viewcluster2 && r_novis.value == 0 && r_viewcluster != -1)
+ return;
+
+ // development aid to let you run around and see exactly where
+ // the pvs ends
+ if (gl_lockpvs.value != 0)
+ return;
+
+ r_visframecount++;
+ r_oldviewcluster = r_viewcluster;
+ r_oldviewcluster2 = r_viewcluster2;
+
+ if (r_novis.value != 0 || r_viewcluster == -1 || r_worldmodel.vis == null)
+ {
+ // mark everything
+ for (i=0 ; i<r_worldmodel.numleafs ; i++)
+ r_worldmodel.leafs[i].visframe = r_visframecount;
+ for (i=0 ; i<r_worldmodel.numnodes ; i++)
+ r_worldmodel.nodes[i].visframe = r_visframecount;
+ return;
+ }
+
+ vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel);
+ // may have to combine two clusters because of solid water boundaries
+ if (r_viewcluster2 != r_viewcluster)
+ {
+ // memcpy (fatvis, vis, (r_worldmodel.numleafs+7)/8);
+ System.arraycopy(vis, 0, fatvis, 0, (r_worldmodel.numleafs+7) / 8);
+ vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel);
+ c = (r_worldmodel.numleafs + 31) / 32;
+ int k = 0;
+ for (i=0 ; i<c ; i++) {
+ fatvis[k] |= vis[k++];
+ fatvis[k] |= vis[k++];
+ fatvis[k] |= vis[k++];
+ fatvis[k] |= vis[k++];
+ }
+
+ vis = fatvis;
+ }
+
+ for ( i=0; i < r_worldmodel.numleafs; i++)
+ {
+ leaf = r_worldmodel.leafs[i];
+ cluster = leaf.cluster;
+ if (cluster == -1)
+ continue;
+ if (((vis[cluster>>3] & 0xFF) & (1 << (cluster & 7))) != 0)
+ {
+ node = (mnode_t)leaf;
+ do
+ {
+ if (node.visframe == r_visframecount)
+ break;
+ node.visframe = r_visframecount;
+ node = node.parent;
+ } while (node != null);
+ }
+ }
+ }
+
+
+
+ /*
+ =============================================================================
+
+ LIGHTMAP ALLOCATION
+
+ =============================================================================
+ */
+
+ void LM_InitBlock()
+ {
+ Arrays.fill(gl_lms.allocated, 0);
+ }
+
+ void LM_UploadBlock( boolean dynamic )
+ {
+ int texture;
+ int height = 0;
+
+ if ( dynamic )
+ {
+ texture = 0;
+ }
+ else
+ {
+ texture = gl_lms.current_lightmap_texture;
+ }
+
+ GL_Bind( gl_state.lightmap_textures + texture );
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+
+ if ( dynamic )
+ {
+ int i;
+
+ for ( i = 0; i < BLOCK_WIDTH; i++ )
+ {
+ if ( gl_lms.allocated[i] > height )
+ height = gl_lms.allocated[i];
+ }
+
+ gl.glTexSubImage2D( GL.GL_TEXTURE_2D,
+ 0,
+ 0, 0,
+ BLOCK_WIDTH, height,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE,
+ gl_lms.lightmap_buffer );
+ }
+ else
+ {
+ gl.glTexImage2D( GL.GL_TEXTURE_2D,
+ 0,
+ gl_lms.internal_format,
+ BLOCK_WIDTH, BLOCK_HEIGHT,
+ 0,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE,
+ gl_lms.lightmap_buffer );
+ if ( ++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS )
+ ri.Sys_Error( Defines.ERR_DROP, "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n" );
+
+
+ //debugLightmap(gl_lms.lightmap_buffer, 128, 128, 4);
+
+ }
+ }
+
+ // returns a texture number and the position inside it
+ boolean LM_AllocBlock (int w, int h, pos_t pos)
+ {
+ int x = pos.x;
+ int y = pos.y;
+ int i, j;
+ int best, best2;
+
+ best = BLOCK_HEIGHT;
+
+ for (i=0 ; i<BLOCK_WIDTH-w ; i++)
+ {
+ best2 = 0;
+
+ for (j=0 ; j<w ; j++)
+ {
+ if (gl_lms.allocated[i+j] >= best)
+ break;
+ if (gl_lms.allocated[i+j] > best2)
+ best2 = gl_lms.allocated[i+j];
+ }
+ if (j == w)
+ { // this is a valid spot
+ pos.x = x = i;
+ pos.y = y = best = best2;
+ }
+ }
+
+ if (best + h > BLOCK_HEIGHT)
+ return false;
+
+ for (i=0 ; i<w ; i++)
+ gl_lms.allocated[x + i] = best + h;
+
+ return true;
+ }
+
+ /*
+ ================
+ GL_BuildPolygonFromSurface
+ ================
+ */
+ void GL_BuildPolygonFromSurface(msurface_t fa)
+ {
+ int i, lindex, lnumverts;
+ medge_t[] pedges;
+ medge_t r_pedge;
+ int vertpage;
+ float[] vec;
+ float s, t;
+ glpoly_t poly;
+ float[] total = {0, 0, 0};
+
+ // reconstruct the polygon
+ pedges = currentmodel.edges;
+ lnumverts = fa.numedges;
+ vertpage = 0;
+
+ Math3D.VectorClear(total);
+ //
+ // draw texture
+ //
+ // poly = Hunk_Alloc (sizeof(glpoly_t) + (lnumverts-4) * VERTEXSIZE*sizeof(float));
+ poly = new glpoly_t(lnumverts);
+
+ poly.next = fa.polys;
+ poly.flags = fa.flags;
+ fa.polys = poly;
+ poly.numverts = lnumverts;
+
+ for (i=0 ; i<lnumverts ; i++)
+ {
+ lindex = currentmodel.surfedges[fa.firstedge + i];
+
+ if (lindex > 0)
+ {
+ r_pedge = pedges[lindex];
+ vec = currentmodel.vertexes[r_pedge.v[0]].position;
+ }
+ else
+ {
+ r_pedge = pedges[-lindex];
+ vec = currentmodel.vertexes[r_pedge.v[1]].position;
+ }
+ s = Math3D.DotProduct (vec, fa.texinfo.vecs[0]) + fa.texinfo.vecs[0][3];
+ s /= fa.texinfo.image.width;
+
+ t = Math3D.DotProduct (vec, fa.texinfo.vecs[1]) + fa.texinfo.vecs[1][3];
+ t /= fa.texinfo.image.height;
+
+ Math3D.VectorAdd (total, vec, total);
+ Math3D.VectorCopy (vec, poly.verts[i]);
+ poly.verts[i][3] = s;
+ poly.verts[i][4] = t;
+
+ //
+ // lightmap texture coordinates
+ //
+ s = Math3D.DotProduct (vec, fa.texinfo.vecs[0]) + fa.texinfo.vecs[0][3];
+ s -= fa.texturemins[0];
+ s += fa.light_s*16;
+ s += 8;
+ s /= BLOCK_WIDTH*16; //fa.texinfo.texture.width;
+
+ t = Math3D.DotProduct (vec, fa.texinfo.vecs[1]) + fa.texinfo.vecs[1][3];
+ t -= fa.texturemins[1];
+ t += fa.light_t*16;
+ t += 8;
+ t /= BLOCK_HEIGHT*16; //fa.texinfo.texture.height;
+
+ poly.verts[i][5] = s;
+ poly.verts[i][6] = t;
+ }
+
+ poly.numverts = lnumverts;
+
+ precompilePolygon(poly);
+
+ }
+
+ /*
+ ========================
+ GL_CreateSurfaceLightmap
+ ========================
+ */
+ void GL_CreateSurfaceLightmap(msurface_t surf)
+ {
+ int smax, tmax;
+ IntBuffer base;
+
+ if ( (surf.flags & (Defines.SURF_DRAWSKY | Defines.SURF_DRAWTURB)) != 0)
+ return;
+
+ smax = (surf.extents[0]>>4)+1;
+ tmax = (surf.extents[1]>>4)+1;
+
+ pos_t lightPos = new pos_t(surf.light_s, surf.light_t);
+
+ if ( !LM_AllocBlock( smax, tmax, lightPos ) )
+ {
+ LM_UploadBlock( false );
+ LM_InitBlock();
+ lightPos = new pos_t(surf.light_s, surf.light_t);
+ if ( !LM_AllocBlock( smax, tmax, lightPos ) )
+ {
+ ri.Sys_Error( Defines.ERR_FATAL, "Consecutive calls to LM_AllocBlock(" + smax +"," + tmax +") failed\n");
+ }
+ }
+
+ // kopiere die koordinaten zurueck
+ surf.light_s = lightPos.x;
+ surf.light_t = lightPos.y;
+
+ surf.lightmaptexturenum = gl_lms.current_lightmap_texture;
+
+ base = gl_lms.lightmap_buffer;
+ base.position(surf.light_t * BLOCK_WIDTH + surf.light_s);
+
+ R_SetCacheState( surf );
+ R_BuildLightMap(surf, base.slice(), BLOCK_WIDTH);
+ }
+
+ lightstyle_t[] lightstyles;
+ IntBuffer dummy = BufferUtils.newIntBuffer(128*128);
+
+ /*
+ ==================
+ GL_BeginBuildingLightmaps
+
+ ==================
+ */
+ void GL_BeginBuildingLightmaps(model_t m)
+ {
+ // static lightstyle_t lightstyles[MAX_LIGHTSTYLES];
+ int i;
+
+ // init lightstyles
+ if ( lightstyles == null ) {
+ lightstyles = new lightstyle_t[Defines.MAX_LIGHTSTYLES];
+ for (i = 0; i < lightstyles.length; i++)
+ {
+ lightstyles[i] = new lightstyle_t();
+ }
+ }
+
+ // memset( gl_lms.allocated, 0, sizeof(gl_lms.allocated) );
+ Arrays.fill(gl_lms.allocated, 0);
+
+ r_framecount = 1; // no dlightcache
+
+ GL_EnableMultitexture( true );
+ GL_SelectTexture( GL_TEXTURE1);
+
+ /*
+ ** setup the base lightstyles so the lightmaps won't have to be regenerated
+ ** the first time they're seen
+ */
+ for (i=0 ; i < Defines.MAX_LIGHTSTYLES ; i++)
+ {
+ lightstyles[i].rgb[0] = 1;
+ lightstyles[i].rgb[1] = 1;
+ lightstyles[i].rgb[2] = 1;
+ lightstyles[i].white = 3;
+ }
+ r_newrefdef.lightstyles = lightstyles;
+
+ if (gl_state.lightmap_textures == 0)
+ {
+ gl_state.lightmap_textures = TEXNUM_LIGHTMAPS;
+ }
+
+ gl_lms.current_lightmap_texture = 1;
+
+ /*
+ ** if mono lightmaps are enabled and we want to use alpha
+ ** blending (a,1-a) then we're likely running on a 3DLabs
+ ** Permedia2. In a perfect world we'd use a GL_ALPHA lightmap
+ ** in order to conserve space and maximize bandwidth, however
+ ** this isn't a perfect world.
+ **
+ ** So we have to use alpha lightmaps, but stored in GL_RGBA format,
+ ** which means we only get 1/16th the color resolution we should when
+ ** using alpha lightmaps. If we find another board that supports
+ ** only alpha lightmaps but that can at least support the GL_ALPHA
+ ** format then we should change this code to use real alpha maps.
+ */
+
+ char format = gl_monolightmap.string.toUpperCase().charAt(0);
+
+ if ( format == 'A' )
+ {
+ gl_lms.internal_format = gl_tex_alpha_format;
+ }
+ /*
+ ** try to do hacked colored lighting with a blended texture
+ */
+ else if ( format == 'C' )
+ {
+ gl_lms.internal_format = gl_tex_alpha_format;
+ }
+ else if ( format == 'I' )
+ {
+ gl_lms.internal_format = GL.GL_INTENSITY8;
+ }
+ else if ( format == 'L' )
+ {
+ gl_lms.internal_format = GL.GL_LUMINANCE8;
+ }
+ else
+ {
+ gl_lms.internal_format = gl_tex_solid_format;
+ }
+
+ /*
+ ** initialize the dynamic lightmap texture
+ */
+ GL_Bind( gl_state.lightmap_textures + 0 );
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+ gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+ gl.glTexImage2D( GL.GL_TEXTURE_2D,
+ 0,
+ gl_lms.internal_format,
+ BLOCK_WIDTH, BLOCK_HEIGHT,
+ 0,
+ GL_LIGHTMAP_FORMAT,
+ GL.GL_UNSIGNED_BYTE,
+ dummy );
+ }
+
+ /*
+ =======================
+ GL_EndBuildingLightmaps
+ =======================
+ */
+ void GL_EndBuildingLightmaps()
+ {
+ LM_UploadBlock( false );
+ GL_EnableMultitexture( false );
+ }
+
+ /*
+ * new functions for vertex array handling
+ */
+ static final int POLYGON_BUFFER_SIZE = 120000;
+ static final int POLYGON_STRIDE = 7;
+ static final int POLYGON_BYTE_STRIDE = POLYGON_STRIDE * BufferUtils.SIZEOF_FLOAT;
+
+ static FloatBuffer globalPolygonInterleavedBuf = BufferUtils.newFloatBuffer(POLYGON_BUFFER_SIZE * 7);
+ static FloatBuffer globalPolygonTexCoord1Buf = null;
+
+ static {
+ globalPolygonInterleavedBuf.position(POLYGON_STRIDE - 2);
+ globalPolygonTexCoord1Buf = globalPolygonInterleavedBuf.slice();
+ globalPolygonInterleavedBuf.position(0);
+ };
+
+ void precompilePolygon(glpoly_t p) {
+
+ p.pos = globalPolygonInterleavedBuf.position() / POLYGON_STRIDE;
+
+ float[] v;
+ FloatBuffer buffer = globalPolygonInterleavedBuf;
+
+ for (int i = 0; i < p.verts.length; i++) {
+ v = p.verts[i];
+ // textureCoord0
+ buffer.put(v[3]);
+ buffer.put(v[4]);
+
+ // vertex
+ buffer.put(v[0]);
+ buffer.put(v[1]);
+ buffer.put(v[2]);
+
+ // textureCoord1
+ buffer.put(v[5]);
+ buffer.put(v[6]);
+ }
+ }
+
+ public static void resetPolygonArrays() {
+ globalPolygonInterleavedBuf.rewind();
+ }
+
+ //ImageFrame frame;
+
+// void debugLightmap(byte[] buf, int w, int h, float scale) {
+// IntBuffer pix = ByteBuffer.wrap(buf).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();
+//
+// int[] pixel = new int[w * h];
+//
+// pix.get(pixel);
+//
+// BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
+// image.setRGB(0, 0, w, h, pixel, 0, w);
+// AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(scale, scale), AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+// BufferedImage tmp = op.filter(image, null);
+//
+// if (frame == null) {
+// frame = new ImageFrame(null);
+// frame.show();
+// }
+// frame.showImage(tmp);
+//
+// }
+
+}
diff --git a/src/jake2/render/fastjogl/Warp.java b/src/jake2/render/fastjogl/Warp.java
new file mode 100644
index 0000000..f9a5b07
--- /dev/null
+++ b/src/jake2/render/fastjogl/Warp.java
@@ -0,0 +1,732 @@
+/*
+ * Warp.java
+ * Copyright (C) 2003
+ *
+ * $Id: Warp.java,v 1.1 2004-07-09 06:50:49 hzi 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.fastjogl;
+
+import java.nio.FloatBuffer;
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.game.GameBase;
+import jake2.render.glpoly_t;
+import jake2.render.image_t;
+import jake2.render.msurface_t;
+import jake2.util.Math3D;
+import net.java.games.jogl.GL;
+
+/**
+ * Warp
+ *
+ * @author cwei
+ */
+public abstract class Warp extends Model {
+
+
+ // warpsin.h
+ public static final float[] SIN = {
+ 0f, 0.19633f, 0.392541f, 0.588517f, 0.784137f, 0.979285f, 1.17384f, 1.3677f,
+ 1.56072f, 1.75281f, 1.94384f, 2.1337f, 2.32228f, 2.50945f, 2.69512f, 2.87916f,
+ 3.06147f, 3.24193f, 3.42044f, 3.59689f, 3.77117f, 3.94319f, 4.11282f, 4.27998f,
+ 4.44456f, 4.60647f, 4.76559f, 4.92185f, 5.07515f, 5.22538f, 5.37247f, 5.51632f,
+ 5.65685f, 5.79398f, 5.92761f, 6.05767f, 6.18408f, 6.30677f, 6.42566f, 6.54068f,
+ 6.65176f, 6.75883f, 6.86183f, 6.9607f, 7.05537f, 7.14579f, 7.23191f, 7.31368f,
+ 7.39104f, 7.46394f, 7.53235f, 7.59623f, 7.65552f, 7.71021f, 7.76025f, 7.80562f,
+ 7.84628f, 7.88222f, 7.91341f, 7.93984f, 7.96148f, 7.97832f, 7.99036f, 7.99759f,
+ 8f, 7.99759f, 7.99036f, 7.97832f, 7.96148f, 7.93984f, 7.91341f, 7.88222f,
+ 7.84628f, 7.80562f, 7.76025f, 7.71021f, 7.65552f, 7.59623f, 7.53235f, 7.46394f,
+ 7.39104f, 7.31368f, 7.23191f, 7.14579f, 7.05537f, 6.9607f, 6.86183f, 6.75883f,
+ 6.65176f, 6.54068f, 6.42566f, 6.30677f, 6.18408f, 6.05767f, 5.92761f, 5.79398f,
+ 5.65685f, 5.51632f, 5.37247f, 5.22538f, 5.07515f, 4.92185f, 4.76559f, 4.60647f,
+ 4.44456f, 4.27998f, 4.11282f, 3.94319f, 3.77117f, 3.59689f, 3.42044f, 3.24193f,
+ 3.06147f, 2.87916f, 2.69512f, 2.50945f, 2.32228f, 2.1337f, 1.94384f, 1.75281f,
+ 1.56072f, 1.3677f, 1.17384f, 0.979285f, 0.784137f, 0.588517f, 0.392541f, 0.19633f,
+ 9.79717e-16f, -0.19633f, -0.392541f, -0.588517f, -0.784137f, -0.979285f, -1.17384f, -1.3677f,
+ -1.56072f, -1.75281f, -1.94384f, -2.1337f, -2.32228f, -2.50945f, -2.69512f, -2.87916f,
+ -3.06147f, -3.24193f, -3.42044f, -3.59689f, -3.77117f, -3.94319f, -4.11282f, -4.27998f,
+ -4.44456f, -4.60647f, -4.76559f, -4.92185f, -5.07515f, -5.22538f, -5.37247f, -5.51632f,
+ -5.65685f, -5.79398f, -5.92761f, -6.05767f, -6.18408f, -6.30677f, -6.42566f, -6.54068f,
+ -6.65176f, -6.75883f, -6.86183f, -6.9607f, -7.05537f, -7.14579f, -7.23191f, -7.31368f,
+ -7.39104f, -7.46394f, -7.53235f, -7.59623f, -7.65552f, -7.71021f, -7.76025f, -7.80562f,
+ -7.84628f, -7.88222f, -7.91341f, -7.93984f, -7.96148f, -7.97832f, -7.99036f, -7.99759f,
+ -8f, -7.99759f, -7.99036f, -7.97832f, -7.96148f, -7.93984f, -7.91341f, -7.88222f,
+ -7.84628f, -7.80562f, -7.76025f, -7.71021f, -7.65552f, -7.59623f, -7.53235f, -7.46394f,
+ -7.39104f, -7.31368f, -7.23191f, -7.14579f, -7.05537f, -6.9607f, -6.86183f, -6.75883f,
+ -6.65176f, -6.54068f, -6.42566f, -6.30677f, -6.18408f, -6.05767f, -5.92761f, -5.79398f,
+ -5.65685f, -5.51632f, -5.37247f, -5.22538f, -5.07515f, -4.92185f, -4.76559f, -4.60647f,
+ -4.44456f, -4.27998f, -4.11282f, -3.94319f, -3.77117f, -3.59689f, -3.42044f, -3.24193f,
+ -3.06147f, -2.87916f, -2.69512f, -2.50945f, -2.32228f, -2.1337f, -1.94384f, -1.75281f,
+ -1.56072f, -1.3677f, -1.17384f, -0.979285f, -0.784137f, -0.588517f, -0.392541f, -0.19633f
+ };
+
+ // gl_warp.c -- sky and water polygons
+ //extern model_t *loadmodel; // Model.java
+
+ String skyname;
+ float skyrotate;
+ float[] skyaxis = {0, 0, 0};
+ image_t[] sky_images = new image_t[6];
+
+ msurface_t warpface;
+
+ static final int SUBDIVIDE_SIZE = 64;
+
+ void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs)
+ {
+ int i, j;
+ float[] v;
+
+ mins[0] = mins[1] = mins[2] = 9999;
+ maxs[0] = maxs[1] = maxs[2] = -9999;
+ for (i=0 ; i<numverts ; i++)
+ {
+ v = verts[i];
+ for (j=0 ; j<3 ; j++)
+ {
+ if (v[j] < mins[j])
+ mins[j] = v[j];
+ if (v[j] > maxs[j])
+ maxs[j] = v[j];
+ }
+ }
+ }
+
+ void SubdividePolygon(int numverts, float[][] verts)
+ {
+ int i, j, k;
+ float[] mins = {0, 0, 0};
+ float[] maxs = {0, 0, 0};
+ float m;
+ float[] v = {0, 0, 0};
+ float[][] front = new float[64][3];
+ float[][] back = new float[64][3];
+
+ int f, b;
+ float[] dist = new float[64];
+ float frac;
+ glpoly_t poly;
+ float s, t;
+ float[] total = {0, 0, 0};
+ float total_s, total_t;
+
+ if (numverts > 60)
+ ri.Sys_Error(Defines.ERR_DROP, "numverts = " + numverts);
+
+ BoundPoly(numverts, verts, mins, maxs);
+
+ // x,y und z
+ for (i=0 ; i<3 ; i++)
+ {
+ m = (mins[i] + maxs[i]) * 0.5f;
+ m = SUBDIVIDE_SIZE * (float)Math.floor(m / SUBDIVIDE_SIZE + 0.5f);
+ if (maxs[i] - m < 8)
+ continue;
+ if (m - mins[i] < 8)
+ continue;
+
+ // cut it
+ for (j=0 ; j<numverts ; j++) {
+ dist[j] = verts[j][i] - m;
+ }
+
+ // wrap cases
+ dist[j] = dist[0];
+
+ Math3D.VectorCopy(verts[0], verts[numverts]);
+
+ f = b = 0;
+ for (j=0 ; j<numverts ; j++)
+ {
+ v = verts[j];
+ if (dist[j] >= 0)
+ {
+ Math3D.VectorCopy(v, front[f]);
+ f++;
+ }
+ if (dist[j] <= 0)
+ {
+ Math3D.VectorCopy(v, back[b]);
+ b++;
+ }
+ if (dist[j] == 0 || dist[j+1] == 0) continue;
+
+ if ( (dist[j] > 0) != (dist[j+1] > 0) )
+ {
+ // clip point
+ frac = dist[j] / (dist[j] - dist[j+1]);
+ for (k=0 ; k<3 ; k++)
+ front[f][k] = back[b][k] = v[k] + frac*(verts[j+1][k] - v[k]);
+
+ f++;
+ b++;
+ }
+ }
+
+ SubdividePolygon(f, front);
+ SubdividePolygon(b, back);
+ return;
+ }
+
+ // add a point in the center to help keep warp valid
+
+ // wird im Konstruktor erschlagen
+ // poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * VERTEXSIZE*sizeof(float));
+
+ // init polys
+ poly = new glpoly_t(numverts + 2);
+
+ poly.next = warpface.polys;
+ warpface.polys = poly;
+ poly.numverts = numverts + 2;
+ Math3D.VectorClear(total);
+ total_s = 0;
+ total_t = 0;
+ for (i=0 ; i<numverts ; i++)
+ {
+ Math3D.VectorCopy(verts[i], poly.verts[i+1]);
+ s = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[0]);
+ t = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[1]);
+
+ total_s += s;
+ total_t += t;
+ Math3D.VectorAdd(total, verts[i], total);
+
+ poly.verts[i+1][3] = s;
+ poly.verts[i+1][4] = t;
+ }
+
+ Math3D.VectorScale(total, (1.0f/numverts), poly.verts[0]);
+ poly.verts[0][3] = total_s/numverts;
+ poly.verts[0][4] = total_t/numverts;
+
+ // memcpy (poly.verts[i+1], poly.verts[1], sizeof(poly.verts[0]));
+ System.arraycopy(poly.verts[1], 0, poly.verts[i+1], 0, poly.verts[1].length); // :-)
+
+ precompilePolygon(poly);
+ }
+
+ /*
+ ================
+ GL_SubdivideSurface
+
+ Breaks a polygon up along axial 64 unit
+ boundaries so that turbulent and sky warps
+ can be done reasonably.
+ ================
+ */
+ void GL_SubdivideSurface(msurface_t fa)
+ {
+ float[][] verts = new float[64][3];
+
+ int numverts;
+ int i;
+ int lindex;
+ float[] vec;
+
+ warpface = fa;
+
+ //
+ // convert edges back to a normal polygon
+ //
+ numverts = 0;
+ for (i=0 ; i < fa.numedges ; i++)
+ {
+ lindex = loadmodel.surfedges[fa.firstedge + i];
+
+ if (lindex > 0)
+ vec = loadmodel.vertexes[loadmodel.edges[lindex].v[0]].position;
+ else
+ vec = loadmodel.vertexes[loadmodel.edges[-lindex].v[1]].position;
+ Math3D.VectorCopy(vec, verts[numverts]);
+ numverts++;
+ }
+
+ SubdividePolygon(numverts, verts);
+ }
+
+// =========================================================
+
+
+
+//// speed up sin calculations - Ed
+// float r_turbsin[] =
+// {
+// #include "warpsin.h"
+// };
+ static final float TURBSCALE = (float)(256.0f / (2 * Math.PI));
+
+ /*
+ =============
+ EmitWaterPolys
+
+ Does a water warp on the pre-fragmented glpoly_t chain
+ =============
+ */
+ void EmitWaterPolys(msurface_t fa)
+ {
+ glpoly_t p, bp;
+ float[] v;
+ int i;
+ float s = 0;
+ float t = 0;
+ float os, ot;
+ float scroll;
+ float rdt = r_newrefdef.time;
+
+ if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0)
+ scroll = -64 * ( (r_newrefdef.time*0.5f) - (int)(r_newrefdef.time*0.5f) );
+ else
+ scroll = 0;
+
+ int index;
+ FloatBuffer texCoord = globalPolygonInterleavedBuf;
+ for (bp=fa.polys ; bp != null ; bp=bp.next)
+ {
+ p = bp;
+
+ index = p.pos * POLYGON_STRIDE;
+ for (i=0; i<p.numverts ; i++)
+ {
+ v = p.verts[i];
+ os = v[3];
+ ot = v[4];
+
+ s = os + Warp.SIN[(int)((ot * 0.125f + r_newrefdef.time) * TURBSCALE) & 255];
+ s += scroll;
+ s *= (1.0f/64);
+
+ t = ot + Warp.SIN[(int)((os * 0.125f + rdt) * TURBSCALE) & 255];
+ t *= (1.0f/64);
+
+ texCoord.put(index, s);
+ texCoord.put(index + 1, t);
+ index += POLYGON_STRIDE;
+ }
+ gl.glDrawArrays(GL.GL_TRIANGLE_FAN, p.pos, p.numverts);
+ }
+ }
+
+// ===================================================================
+
+
+ float[][] skyclip = {
+ { 1, 1, 0},
+ { 1, -1, 0},
+ { 0, -1, 1},
+ { 0, 1, 1},
+ { 1, 0, 1},
+ {-1, 0, 1}
+ };
+
+ int c_sky;
+
+ // 1 = s, 2 = t, 3 = 2048
+ int[][] st_to_vec =
+ {
+ {3,-1,2},
+ {-3,1,2},
+
+ {1,3,2},
+ {-1,-3,2},
+
+ {-2,-1,3}, // 0 degrees yaw, look straight up
+ {2,-1,-3} // look straight down
+
+ };
+
+ int[][] vec_to_st =
+ {
+ {-2,3,1},
+ {2,3,-1},
+
+ {1,3,2},
+ {-1,3,-2},
+
+ {-2,-1,3},
+ {-2,1,-3}
+
+ };
+
+ float[][] skymins = new float[2][6];
+ float[][] skymaxs = new float[2][6];
+ float sky_min, sky_max;
+
+ void DrawSkyPolygon (int nump, float[][] vecs)
+ {
+ int i,j;
+ float[] v = {0, 0, 0};
+ float[] av = {0, 0, 0};
+ float s, t, dv;
+ int axis;
+ float[] vp;
+
+ c_sky++;
+ // decide which face it maps to
+ Math3D.VectorCopy(Globals.vec3_origin, v);
+ for (i=0; i<nump ; i++)
+ {
+ Math3D.VectorAdd(vecs[i], v, v);
+ }
+ av[0] = Math.abs(v[0]);
+ av[1] = Math.abs(v[1]);
+ av[2] = Math.abs(v[2]);
+ if (av[0] > av[1] && av[0] > av[2])
+ {
+ if (v[0] < 0)
+ axis = 1;
+ else
+ axis = 0;
+ }
+ else if (av[1] > av[2] && av[1] > av[0])
+ {
+ if (v[1] < 0)
+ axis = 3;
+ else
+ axis = 2;
+ }
+ else
+ {
+ if (v[2] < 0)
+ axis = 5;
+ else
+ axis = 4;
+ }
+
+ // project new texture coords
+ for (i=0 ; i<nump ; i++)
+ {
+ j = vec_to_st[axis][2];
+ if (j > 0)
+ dv = vecs[i][j - 1];
+ else
+ dv = -vecs[i][-j - 1];
+ if (dv < 0.001f)
+ continue; // don't divide by zero
+ j = vec_to_st[axis][0];
+ if (j < 0)
+ s = -vecs[i][-j -1] / dv;
+ else
+ s = vecs[i][j-1] / dv;
+ j = vec_to_st[axis][1];
+ if (j < 0)
+ t = -vecs[i][-j -1] / dv;
+ else
+ t = vecs[i][j-1] / dv;
+
+ if (s < skymins[0][axis])
+ skymins[0][axis] = s;
+ if (t < skymins[1][axis])
+ skymins[1][axis] = t;
+ if (s > skymaxs[0][axis])
+ skymaxs[0][axis] = s;
+ if (t > skymaxs[1][axis])
+ skymaxs[1][axis] = t;
+ }
+ }
+
+ static final float ON_EPSILON = 0.1f; // point on plane side epsilon
+ static final int MAX_CLIP_VERTS = 64;
+
+ static final int SIDE_BACK = 1;
+ static final int SIDE_FRONT = 0;
+ static final int SIDE_ON = 2;
+
+ float[] dists = new float[MAX_CLIP_VERTS];
+ int[] sides = new int[MAX_CLIP_VERTS];
+ float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3];
+
+ void ClipSkyPolygon(int nump, float[][] vecs, int stage)
+ {
+ float[] norm;
+ float[] v;
+ boolean front, back;
+ float d, e;
+ int[] newc = { 0, 0 };
+ int i, j;
+
+ if (nump > MAX_CLIP_VERTS-2)
+ ri.Sys_Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS");
+ if (stage == 6)
+ { // fully clipped, so draw it
+ DrawSkyPolygon(nump, vecs);
+ return;
+ }
+
+ front = back = false;
+ norm = skyclip[stage];
+ for (i=0 ; i<nump ; i++)
+ {
+ d = Math3D.DotProduct(vecs[i], norm);
+ if (d > ON_EPSILON)
+ {
+ front = true;
+ sides[i] = SIDE_FRONT;
+ }
+ else if (d < -ON_EPSILON)
+ {
+ back = true;
+ sides[i] = SIDE_BACK;
+ }
+ else
+ sides[i] = SIDE_ON;
+ dists[i] = d;
+ }
+
+ if (!front || !back)
+ { // not clipped
+ ClipSkyPolygon (nump, vecs, stage+1);
+ return;
+ }
+
+ // clip it
+ sides[i] = sides[0];
+ dists[i] = dists[0];
+ Math3D.VectorCopy(vecs[0], vecs[i]);
+ newc[0] = newc[1] = 0;
+
+ for (i=0; i<nump ; i++)
+ {
+ v = vecs[i];
+ switch (sides[i])
+ {
+ case SIDE_FRONT:
+ Math3D.VectorCopy(v, newv[stage][0][newc[0]]);
+ newc[0]++;
+ break;
+ case SIDE_BACK:
+ Math3D.VectorCopy(v, newv[stage][1][newc[1]]);
+ newc[1]++;
+ break;
+ case SIDE_ON:
+ Math3D.VectorCopy(v, newv[stage][0][newc[0]]);
+ newc[0]++;
+ Math3D.VectorCopy (v, newv[stage][1][newc[1]]);
+ newc[1]++;
+ break;
+ }
+
+ if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+ continue;
+
+ d = dists[i] / (dists[i] - dists[i+1]);
+ for (j=0 ; j<3 ; j++)
+ {
+ e = v[j] + d * (vecs[i + 1][j] - v[j]);
+ newv[stage][0][newc[0]][j] = e;
+ newv[stage][1][newc[1]][j] = e;
+ }
+ newc[0]++;
+ newc[1]++;
+ }
+
+ // continue
+ ClipSkyPolygon(newc[0], newv[stage][0], stage+1);
+ ClipSkyPolygon(newc[1], newv[stage][1], stage+1);
+ }
+
+ float[][] verts = new float[MAX_CLIP_VERTS][3];
+
+ /*
+ =================
+ R_AddSkySurface
+ =================
+ */
+ void R_AddSkySurface(msurface_t fa)
+ {
+ int i;
+ glpoly_t p;
+
+ // calculate vertex values for sky box
+ for (p=fa.polys ; p != null ; p=p.next)
+ {
+ for (i=0 ; i < p.numverts ; i++)
+ {
+ Math3D.VectorSubtract(p.verts[i], r_origin, verts[i]);
+ }
+ ClipSkyPolygon (p.numverts, verts, 0);
+ }
+ }
+
+
+ /*
+ ==============
+ R_ClearSkyBox
+ ==============
+ */
+ void R_ClearSkyBox()
+ {
+ int i;
+
+ for (i=0 ; i<6 ; i++)
+ {
+ skymins[0][i] = skymins[1][i] = 9999;
+ skymaxs[0][i] = skymaxs[1][i] = -9999;
+ }
+ }
+
+
+ void MakeSkyVec (float s, float t, int axis)
+ {
+ float[] v = {0, 0, 0};
+ float[] b = {0, 0, 0};
+ int j, k;
+
+ b[0] = s*2300;
+ b[1] = t*2300;
+ b[2] = 2300;
+
+ for (j=0 ; j<3 ; j++)
+ {
+ k = st_to_vec[axis][j];
+ if (k < 0)
+ v[j] = -b[-k - 1];
+ else
+ v[j] = b[k - 1];
+ }
+
+ // avoid bilerp seam
+ s = (s + 1) * 0.5f;
+ t = (t + 1) * 0.5f;
+
+ if (s < sky_min)
+ s = sky_min;
+ else if (s > sky_max)
+ s = sky_max;
+ if (t < sky_min)
+ t = sky_min;
+ else if (t > sky_max)
+ t = sky_max;
+
+ t = 1.0f - t;
+ gl.glTexCoord2f (s, t);
+ gl.glVertex3f(v[0], v[1], v[2]);
+ }
+
+ /*
+ ==============
+ R_DrawSkyBox
+ ==============
+ */
+ int[] skytexorder = {0,2,1,3,4,5};
+
+ void R_DrawSkyBox()
+ {
+ int i;
+
+ if (skyrotate != 0)
+ { // check for no sky at all
+ for (i=0 ; i<6 ; i++)
+ if (skymins[0][i] < skymaxs[0][i]
+ && skymins[1][i] < skymaxs[1][i])
+ break;
+ if (i == 6)
+ return; // nothing visible
+ }
+
+ gl.glPushMatrix ();
+ gl.glTranslatef (r_origin[0], r_origin[1], r_origin[2]);
+ gl.glRotatef (r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);
+
+ for (i=0 ; i<6 ; i++)
+ {
+ if (skyrotate != 0)
+ { // hack, forces full sky to draw when rotating
+ skymins[0][i] = -1;
+ skymins[1][i] = -1;
+ skymaxs[0][i] = 1;
+ skymaxs[1][i] = 1;
+ }
+
+ if (skymins[0][i] >= skymaxs[0][i]
+ || skymins[1][i] >= skymaxs[1][i])
+ continue;
+
+ GL_Bind(sky_images[skytexorder[i]].texnum);
+
+ gl.glBegin(GL.GL_QUADS);
+ MakeSkyVec(skymins[0][i], skymins[1][i], i);
+ MakeSkyVec(skymins[0][i], skymaxs[1][i], i);
+ MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i);
+ MakeSkyVec(skymaxs[0][i], skymins[1][i], i);
+ gl.glEnd ();
+ }
+ gl.glPopMatrix ();
+ }
+
+
+ /*
+ ============
+ R_SetSky
+ ============
+ */
+ // 3dstudio environment map names
+ String[] suf = {"rt", "bk", "lf", "ft", "up", "dn"};
+
+ protected void R_SetSky(String name, float rotate, float[] axis)
+ {
+ assert (axis.length == 3) : "vec3_t bug";
+ int i;
+ String pathname;
+
+// strncpy (skyname, name, sizeof(skyname)-1);
+ skyname = name;
+
+ skyrotate = rotate;
+ Math3D.VectorCopy(axis, skyaxis);
+
+ for (i=0 ; i<6 ; i++)
+ {
+ // chop down rotating skies for less memory
+ if (gl_skymip.value != 0 || skyrotate != 0)
+ gl_picmip.value++;
+
+ if ( qglColorTableEXT && gl_ext_palettedtexture.value != 0) {
+ // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx", skyname, suf[i]);
+ pathname = "env/" + skyname + suf[i] + ".pcx";
+ } else {
+ // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.tga", skyname, suf[i]);
+ pathname = "env/" + skyname + suf[i] + ".tga";
+ }
+
+ sky_images[i] = GL_FindImage(pathname, it_sky);
+
+ if (sky_images[i] == null)
+ sky_images[i] = r_notexture;
+
+ if (gl_skymip.value != 0 || skyrotate != 0)
+ { // take less memory
+ gl_picmip.value--;
+ sky_min = 1.0f / 256;
+ sky_max = 255.0f / 256;
+ }
+ else
+ {
+ sky_min = 1.0f / 512;
+ sky_max = 511.0f / 512;
+ }
+ }
+ }
+
+
+}
diff --git a/src/jake2/sound/WaveLoader.java b/src/jake2/sound/WaveLoader.java
new file mode 100644
index 0000000..020ab52
--- /dev/null
+++ b/src/jake2/sound/WaveLoader.java
@@ -0,0 +1,302 @@
+/*
+ * SND_MEM.java
+ * Copyright (C) 2004
+ *
+ * $Id: WaveLoader.java,v 1.1 2004-07-09 06:50:48 hzi 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.sound;
+
+import jake2.Defines;
+import jake2.qcommon.Com;
+import jake2.qcommon.FS;
+import jake2.sys.Sys;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+import javax.sound.sampled.*;
+
+/**
+ * SND_MEM
+ */
+public class WaveLoader {
+
+ private static final AudioFormat sampleFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, 22050, 16, 1, 2, 22050, false);
+
+ /*
+ ==============
+ S_LoadSound
+ ==============
+ */
+ public static sfxcache_t LoadSound(sfx_t s) {
+ String namebuffer;
+ byte[] data;
+ wavinfo_t info;
+ int len;
+ float stepscale;
+ sfxcache_t sc = null;
+ int size;
+ String name;
+
+ if (s.name.charAt(0) == '*')
+ return null;
+
+ // see if still in memory
+ sc = s.cache;
+ if (sc != null)
+ return sc;
+
+ // load it in
+ if (s.truename != null)
+ name = s.truename;
+ else
+ name = s.name;
+
+ if (name.charAt(0) == '#')
+ namebuffer = name.substring(1);
+
+ else
+ namebuffer = "sound/" + name;
+
+ data = FS.LoadFile(namebuffer);
+
+ if (data == null) {
+ Com.DPrintf("Couldn't load " + namebuffer + "\n");
+ return null;
+ }
+ size = data.length;
+
+ info = GetWavinfo(s.name, data, size);
+
+ AudioInputStream in = null;
+ AudioInputStream out = null;
+ try {
+ in = AudioSystem.getAudioInputStream(new ByteArrayInputStream(data));
+ if (in.getFormat().getSampleSizeInBits() == 8) {
+ in = convertTo16bit(in);
+ }
+ out = AudioSystem.getAudioInputStream(sampleFormat, in);
+ int l = (int)out.getFrameLength();
+ sc = s.cache = new sfxcache_t(l*2);
+ sc.length = l;
+ int c = out.read(sc.data, 0, l * 2);
+ out.close();
+ in.close();
+ } catch (Exception e) {
+ Com.Printf("Couldn't load " + namebuffer + "\n");
+ return null;
+ }
+
+ sc.loopstart = info.loopstart * ((int)sampleFormat.getSampleRate() / info.rate);
+ sc.speed = (int)sampleFormat.getSampleRate();
+ sc.width = sampleFormat.getSampleSizeInBits() / 8;
+ sc.stereo = 0;
+
+ data = null;
+
+ return sc;
+ }
+
+ static AudioInputStream convertTo16bit(AudioInputStream in) throws IOException {
+ AudioFormat format = in.getFormat();
+ int length = (int)in.getFrameLength();
+ byte[] samples = new byte[2*length];
+
+ for (int i = 0; i < length; i++) {
+ in.read(samples, 2*i+1, 1);
+ samples[2*i+1] -= 128;
+ }
+ in.close();
+
+ AudioFormat newformat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, format.getSampleRate(), 16, format.getChannels(), 2, format.getFrameRate(), false);
+ return new AudioInputStream(new ByteArrayInputStream(samples), newformat, length);
+ }
+
+ /*
+ ===============================================================================
+
+ WAV loading
+
+ ===============================================================================
+ */
+
+ static byte[] data_b;
+ static int data_p;
+ static int iff_end;
+ static int last_chunk;
+ static int iff_data;
+ static int iff_chunk_len;
+
+
+ static short GetLittleShort() {
+ int val = 0;
+ val = data_b[data_p] & 0xFF;
+ data_p++;
+ val |= ((data_b[data_p] & 0xFF) << 8);
+ data_p++;
+ return (short)val;
+ }
+
+ static int GetLittleLong() {
+ int val = 0;
+ val = data_b[data_p] & 0xFF;
+ data_p++;
+ val |= ((data_b[data_p] & 0xFF) << 8);
+ data_p++;
+ val |= ((data_b[data_p] & 0xFF) << 16);
+ data_p++;
+ val |= ((data_b[data_p] & 0xFF) << 24);
+ data_p++;
+ return val;
+ }
+
+ static void FindNextChunk(String name) {
+ while (true) {
+ data_p = last_chunk;
+
+ if (data_p >= iff_end) { // didn't find the chunk
+ data_p = 0;
+ return;
+ }
+
+ data_p += 4;
+
+ iff_chunk_len = GetLittleLong();
+
+ if (iff_chunk_len < 0) {
+ data_p = 0;
+ return;
+ }
+ if (iff_chunk_len > 1024*1024)
+ Sys.Error("FindNextChunk: length is past the 1 meg sanity limit");
+
+ data_p -= 8;
+ last_chunk = data_p + 8 + ((iff_chunk_len + 1) & ~1);
+ String s = new String(data_b, data_p, 4);
+ if (s.equals(name))
+ return;
+ }
+ }
+
+ static void FindChunk(String name) {
+ last_chunk = iff_data;
+ FindNextChunk(name);
+ }
+
+ /*
+ ============
+ GetWavinfo
+ ============
+ */
+ static wavinfo_t GetWavinfo(String name, byte[] wav, int wavlength) {
+ wavinfo_t info = new wavinfo_t();
+ int i;
+ int format;
+ int samples;
+
+ if (wav == null)
+ return info;
+
+ iff_data = 0;
+ iff_end = wavlength;
+ data_b = wav;
+
+ // find "RIFF" chunk
+ FindChunk("RIFF");
+ String s = new String(data_b, data_p + 8, 4);
+ if (!s.equals("WAVE")) {
+ Com.Printf("Missing RIFF/WAVE chunks\n");
+ return info;
+ }
+
+ // get "fmt " chunk
+ iff_data = data_p + 12;
+ // DumpChunks ();
+
+ FindChunk("fmt ");
+ if (data_p == 0) {
+ Com.Printf("Missing fmt chunk\n");
+ return info;
+ }
+ data_p += 8;
+ format = GetLittleShort();
+ if (format != 1) {
+ Com.Printf("Microsoft PCM format only\n");
+ return info;
+ }
+
+ info.channels = GetLittleShort();
+ info.rate = GetLittleLong();
+ data_p += 4 + 2;
+ info.width = GetLittleShort() / 8;
+
+ // get cue chunk
+ FindChunk("cue ");
+ if (data_p != 0) {
+ data_p += 32;
+ info.loopstart = GetLittleLong();
+ // Com_Printf("loopstart=%d\n", sfx->loopstart);
+
+ // if the next chunk is a LIST chunk, look for a cue length marker
+ FindNextChunk("LIST");
+ if (data_p != 0) {
+ s = new String(data_b, data_p + 28, 4);
+ if (s.equals("MARK")) { // this is not a proper parse, but it works with cooledit...
+ data_p += 24;
+ i = GetLittleLong(); // samples in loop
+ info.samples = info.loopstart + i;
+ // Com_Printf("looped length: %i\n", i);
+ }
+ }
+ } else
+ info.loopstart = -1;
+
+ // find data chunk
+ FindChunk("data");
+ if (data_p == 0) {
+ Com.Printf("Missing data chunk\n");
+ return info;
+ }
+
+ data_p += 4;
+ samples = GetLittleLong() / info.width;
+
+ if (info.samples != 0) {
+ if (samples < info.samples)
+ Com.Error(Defines.ERR_DROP, "Sound " + name + " has a bad loop length");
+ } else
+ info.samples = samples;
+
+ info.dataofs = data_p;
+
+ return info;
+ }
+
+ static class wavinfo_t {
+ int rate;
+ int width;
+ int channels;
+ int loopstart;
+ int samples;
+ int dataofs; // chunk starts this many bytes from file start
+ }
+}
diff --git a/src/jake2/sound/joal/Channel.java b/src/jake2/sound/joal/Channel.java
new file mode 100644
index 0000000..ced496f
--- /dev/null
+++ b/src/jake2/sound/joal/Channel.java
@@ -0,0 +1,84 @@
+/*
+ * Created on Jun 19, 2004
+ *
+ * Copyright (C) 2003
+ *
+ * $Id: Channel.java,v 1.1 2004-07-09 06:50:52 hzi 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.sound.joal;
+
+/**
+ * Channel
+ *
+ * @author cwei
+ */
+public class Channel {
+
+ final static int LISTENER = 0;
+ final static int FIXED = 1;
+ final static int DYNAMIC = 2;
+
+ int entnum;
+ int entchannel;
+ int bufferId;
+ float rolloff;
+ boolean autosound = false;
+ int sourceId;
+ boolean active = false;
+ boolean modified = false;
+ boolean bufferChanged = false;
+
+ // sound attributes
+ int type;
+ int entity;
+ float[] origin = {0, 0, 0};
+
+ Channel(int sourceId) {
+ this.sourceId = sourceId;
+ clear();
+ }
+
+ void addListener() {
+ type = LISTENER;
+ }
+
+ void addFixed(float[] origin) {
+ type = FIXED;
+ this.origin = origin;
+ }
+
+ void addDynamic(int entity) {
+ type = DYNAMIC;
+ this.entity = entity;
+ }
+
+ void clear() {
+ entnum = -1;
+ entchannel = -1;
+ bufferId = -1;
+ bufferChanged = false;
+ rolloff = 0;
+ autosound = false;
+ active = false;
+ modified = false;
+ }
+}
diff --git a/src/jake2/sound/joal/JOALSoundImpl.java b/src/jake2/sound/joal/JOALSoundImpl.java
new file mode 100644
index 0000000..8a005ce
--- /dev/null
+++ b/src/jake2/sound/joal/JOALSoundImpl.java
@@ -0,0 +1,793 @@
+/*
+ * JOALSoundImpl.java
+ * Copyright (C) 2004
+ *
+ * $Id: JOALSoundImpl.java,v 1.1 2004-07-09 06:50:52 hzi Exp $
+ */
+package jake2.sound.joal;
+
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.client.CL;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.sound.*;
+import jake2.util.Math3D;
+import jake2.util.Vargs;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.*;
+
+import net.java.games.joal.*;
+
+/**
+ * JOALSoundImpl
+ */
+public final class JOALSoundImpl implements Sound {
+
+ static {
+ S.register(new JOALSoundImpl());
+ };
+
+ static AL al;
+ static ALC alc;
+
+ cvar_t s_volume;
+
+ private static final int MAX_SFX = Defines.MAX_SOUNDS * 2;
+ private static final int MAX_CHANNELS = 32;
+
+ private int[] buffers = new int[MAX_SFX];
+ private int[] sources = new int[MAX_CHANNELS];
+ private Channel[] channels = null;
+
+ private JOALSoundImpl() {
+ }
+
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#Init()
+ */
+ public boolean Init() {
+
+ try {
+ initOpenAL();
+ al = ALFactory.getAL();
+ checkError();
+ } catch (OpenALException e) {
+ Com.Printf(e.getMessage() + '\n');
+ return false;
+ }
+
+ checkError();
+ al.alGenBuffers(MAX_SFX, buffers);
+ al.alGenSources(MAX_CHANNELS, sources);
+ checkError();
+ s_volume = Cvar.Get("s_volume", "0.7", Defines.CVAR_ARCHIVE);
+ initChannels();
+ al.alDistanceModel(AL.AL_INVERSE_DISTANCE_CLAMPED);
+// al.alDistanceModel(AL.AL_INVERSE_DISTANCE);
+ Cmd.AddCommand("play", new xcommand_t() {
+ public void execute() {
+ Play();
+ }
+ });
+ Cmd.AddCommand("stopsound", new xcommand_t() {
+ public void execute() {
+ StopAllSounds();
+ }
+ });
+ Cmd.AddCommand("soundlist", new xcommand_t() {
+ public void execute() {
+ SoundList();
+ }
+ });
+ Cmd.AddCommand("soundinfo", new xcommand_t() {
+ public void execute() {
+ SoundInfo_f();
+ }
+ });
+
+ num_sfx = 0;
+
+
+ Com.Printf("sound sampling rate: 44100Hz\n");
+
+ StopAllSounds();
+ Com.Printf("------------------------------------\n");
+ return true;
+ }
+
+
+ private void initOpenAL() throws OpenALException {
+ ALFactory.initialize();
+ alc = ALFactory.getALC();
+ String deviceName = null;
+
+ String os = System.getProperty("os.name");
+ if (os.startsWith("Windows")) {
+ deviceName = "DirectSound3D";
+ }
+ ALC.Device device = alc.alcOpenDevice(deviceName);
+ String deviceSpecifier = alc.alcGetString(device, ALC.ALC_DEVICE_SPECIFIER);
+ String defaultSpecifier = alc.alcGetString(device, ALC.ALC_DEFAULT_DEVICE_SPECIFIER);
+
+ Com.Printf(os + " using " + ((deviceName == null) ? defaultSpecifier : deviceName) + '\n');
+
+ ALC.Context context = alc.alcCreateContext(device, new int[] {0});
+ alc.alcMakeContextCurrent(context);
+ // Check for an error.
+ if (alc.alcGetError(device) != ALC.ALC_NO_ERROR) {
+ Com.DPrintf("Error with SoundDevice");
+ }
+ }
+
+ void exitOpenAL() {
+ // Get the current context.
+ ALC.Context curContext = alc.alcGetCurrentContext();
+ // Get the device used by that context.
+ ALC.Device curDevice = alc.alcGetContextsDevice(curContext);
+ // Reset the current context to NULL.
+ alc.alcMakeContextCurrent(null);
+ // Release the context and the device.
+ alc.alcDestroyContext(curContext);
+ alc.alcCloseDevice(curDevice);
+ }
+
+ private void initChannels() {
+
+ // create channels
+ channels = new Channel[MAX_CHANNELS];
+
+ int sourceId;
+ for (int i = 0; i < MAX_CHANNELS; i++) {
+ sourceId = sources[i];
+ channels[i] = new Channel(sourceId);
+
+ // set default values for AL sources
+ al.alSourcef (sourceId, AL.AL_GAIN, s_volume.value);
+ al.alSourcef (sourceId, AL.AL_PITCH, 1.0f);
+ al.alSourcei (sourceId, AL.AL_SOURCE_ABSOLUTE, AL.AL_TRUE);
+ al.alSourcefv(sourceId, AL.AL_VELOCITY, NULLVECTOR);
+ al.alSourcei (sourceId, AL.AL_LOOPING, AL.AL_FALSE);
+ al.alSourcef (sourceId, AL.AL_REFERENCE_DISTANCE, 300.0f);
+ al.alSourcef (sourceId, AL.AL_MIN_GAIN, 0.0005f);
+ al.alSourcef (sourceId, AL.AL_MAX_GAIN, 1.0f);
+ }
+ }
+
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#RegisterSound(jake2.sound.sfx_t)
+ */
+ private void initBuffer(sfx_t sfx)
+ {
+ if (sfx.cache == null ) {
+ //System.out.println(sfx.name + " " + sfx.cache.length+ " " + sfx.cache.loopstart + " " + sfx.cache.speed + " " + sfx.cache.stereo + " " + sfx.cache.width);
+ return;
+ }
+
+ int format = AL.AL_FORMAT_MONO16;
+ byte[] data = sfx.cache.data;
+ int freq = sfx.cache.speed;
+ int size = data.length;
+
+// if (buffers[sfx.id] != 0)
+// al.alDeleteBuffers(1, new int[] {buffers[sfx.id] });
+//
+// int[] bid = new int[1];
+// al.alBufferData( bid[0], format, data, size, freq);
+// buffers[sfx.id] = bid[0];
+// al.alBufferData( bid[0], format, data, size, freq);
+
+ al.alBufferData( buffers[sfx.id], format, data, size, freq);
+// int error;
+// if ((error = al.alGetError()) != AL.AL_NO_ERROR) {
+// String message;
+// switch(error) {
+// case AL.AL_INVALID_OPERATION: message = "invalid operation"; break;
+// case AL.AL_INVALID_VALUE: message = "invalid value"; break;
+// case AL.AL_INVALID_ENUM: message = "invalid enum"; break;
+// case AL.AL_INVALID_NAME: message = "invalid name"; break;
+// default: message = "" + error;
+// }
+// Com.DPrintf("Error Buffer " + sfx.id + ": " + sfx.name + " (" + size + ") --> " + message + '\n');
+// }
+ }
+
+ private void checkError() {
+ int error;
+ if ((error = al.alGetError()) != AL.AL_NO_ERROR) {
+ String message;
+ switch(error) {
+ case AL.AL_INVALID_OPERATION: message = "invalid operation"; break;
+ case AL.AL_INVALID_VALUE: message = "invalid value"; break;
+ case AL.AL_INVALID_ENUM: message = "invalid enum"; break;
+ case AL.AL_INVALID_NAME: message = "invalid name"; break;
+ default: message = "" + error;
+ }
+ Com.DPrintf("AL Error: " + message +'\n');
+ }
+ }
+
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#Shutdown()
+ */
+ public void Shutdown() {
+ StopAllSounds();
+ al.alDeleteSources(sources.length, sources);
+ al.alDeleteBuffers(buffers.length, buffers);
+ exitOpenAL();
+ //ALut.alutExit();
+ Cmd.RemoveCommand("play");
+ Cmd.RemoveCommand("stopsound");
+ Cmd.RemoveCommand("soundlist");
+ Cmd.RemoveCommand("soundinfo");
+
+ // free all sounds
+ for (int i = 0; i < num_sfx; i++) {
+ if (known_sfx[i].name == null)
+ continue;
+ known_sfx[i].clear();
+ }
+ num_sfx = 0;
+ }
+
+ private final static float[] NULLVECTOR = {0, 0, 0};
+ private float[] entityOrigin = {0, 0, 0};
+ private float[] sourceOrigin = {0, 0, 0};
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#StartSound(float[], int, int, jake2.sound.sfx_t, float, float, float)
+ */
+ public void StartSound(float[] origin, int entnum, int entchannel, sfx_t sfx, float fvol, float attenuation, float timeofs) {
+
+ if (sfx == null)
+ return;
+
+ if (sfx.name.charAt(0) == '*')
+ sfx = RegisterSexedSound(Globals.cl_entities[entnum].current, sfx.name);
+
+ if (LoadSound(sfx) == null)
+ return; // can't load sound
+
+ if (attenuation != Defines.ATTN_STATIC)
+ attenuation *= 0.5f;
+
+ Channel ch = pickChannel(entnum, entchannel, buffers[sfx.id], attenuation);
+
+ if (ch == null) return;
+
+ if (entnum == Globals.cl.playernum + 1) {
+ ch.addListener();
+ } else if (origin != null) {
+ ch.addFixed(origin);
+ } else {
+ ch.addDynamic(entnum);
+ }
+ }
+
+ Channel pickChannel(int entnum, int entchannel, int bufferId, float rolloff) {
+
+ Channel ch = null;
+ int state;
+ int i;
+
+ for (i = 0; i < MAX_CHANNELS; i++) {
+ ch = channels[i];
+
+ if (entchannel != 0 && ch.entnum == entnum && ch.entchannel == entchannel) {
+ // always override sound from same entity
+ break;
+ }
+
+ // don't let monster sounds override player sounds
+ if ((ch.entnum == Globals.cl.playernum+1) && (entnum != Globals.cl.playernum+1) && ch.bufferId != -1)
+ continue;
+
+ // looking for a free AL source
+ if (!ch.active) {
+ break;
+ }
+ }
+
+ if (i == MAX_CHANNELS)
+ return null;
+
+ ch.entnum = entnum;
+ ch.entchannel = entchannel;
+ if (ch.bufferId != bufferId) {
+ ch.bufferId = bufferId;
+ ch.bufferChanged = true;
+ }
+ ch.rolloff = rolloff * 2;
+ ch.active = true;
+ ch.modified = true;
+
+ return ch;
+ }
+
+ private float[] listenerOrigin = {0, 0, 0};
+ private float[] listenerOrientation = {0, 0, 0, 0, 0, 0};
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#Update(float[], float[], float[], float[])
+ */
+ public void Update(float[] origin, float[] forward, float[] right, float[] up) {
+
+ convertVector(origin, listenerOrigin);
+ al.alListenerfv(AL.AL_POSITION, listenerOrigin);
+
+ convertOrientation(forward, up, listenerOrientation);
+ al.alListenerfv(AL.AL_ORIENTATION, listenerOrientation);
+
+ AddLoopSounds(origin);
+ playChannels(listenerOrigin);
+ }
+
+ Map looptable = new Hashtable(2 * MAX_CHANNELS);
+
+ /*
+ ==================
+ S_AddLoopSounds
+
+ Entities with a ->sound field will generated looped sounds
+ that are automatically started, stopped, and merged together
+ as the entities are sent to the client
+ ==================
+ */
+ void AddLoopSounds(float[] listener) {
+
+ if (Globals.cl_paused.value != 0.0f) {
+ removeUnusedLoopSounds();
+ return;
+ }
+
+ if (Globals.cls.state != Globals.ca_active) {
+ removeUnusedLoopSounds();
+ return;
+ }
+
+ if (!Globals.cl.sound_prepped) {
+ removeUnusedLoopSounds();
+ return;
+ }
+
+ Channel ch;
+ sfx_t sfx;
+ sfxcache_t sc;
+ int num;
+ entity_state_t ent;
+ Object key;
+ int sound = 0;
+
+ for (int i=0 ; i<Globals.cl.frame.num_entities ; i++) {
+ num = (Globals.cl.frame.parse_entities + i)&(Defines.MAX_PARSE_ENTITIES-1);
+ ent = Globals.cl_parse_entities[num];
+ sound = ent.sound;
+
+ if (sound == 0) continue;
+
+ key = new Integer(ent.number);
+ ch = (Channel)looptable.get(key);
+
+ if (ch != null) {
+ // keep on looping
+ ch.autosound = true;
+ ch.origin = ent.origin;
+ continue;
+ }
+
+ sfx = Globals.cl.sound_precache[sound];
+ if (sfx == null)
+ continue; // bad sound effect
+
+ sc = sfx.cache;
+ if (sc == null)
+ continue;
+
+ // allocate a channel
+ ch = pickChannel(0, 0, buffers[sfx.id], 6);
+ if (ch == null)
+ break;
+
+ ch.addFixed(ent.origin);
+ ch.autosound = true;
+
+ looptable.put(key, ch);
+ al.alSourcei(ch.sourceId, AL.AL_LOOPING, AL.AL_TRUE);
+ }
+
+ removeUnusedLoopSounds();
+
+ }
+
+ void removeUnusedLoopSounds() {
+ Channel ch;
+ // stop unused loopsounds
+ for (Iterator iter = looptable.values().iterator(); iter.hasNext();) {
+ ch = (Channel)iter.next();
+ if (!ch.autosound) {
+ al.alSourceStop(ch.sourceId);
+ al.alSourcei(ch.sourceId, AL.AL_LOOPING, AL.AL_FALSE);
+ iter.remove();
+ ch.clear();
+ }
+ }
+ }
+
+ void playChannels(float[] listenerOrigin) {
+
+ float[] sourceOrigin = {0, 0, 0};
+ float[] entityOrigin = {0, 0, 0};
+ Channel ch;
+ int sourceId;
+ int state;
+
+ for (int i = 0; i < MAX_CHANNELS; i++) {
+ ch = channels[i];
+ if (ch.active) {
+ sourceId = ch.sourceId;
+
+ switch (ch.type) {
+ case Channel.LISTENER:
+ Math3D.VectorCopy(listenerOrigin, sourceOrigin);
+ break;
+ case Channel.DYNAMIC:
+ CL.GetEntitySoundOrigin(ch.entity, entityOrigin);
+ convertVector(entityOrigin, sourceOrigin);
+ break;
+ case Channel.FIXED:
+ convertVector(ch.origin, sourceOrigin);
+ break;
+ }
+
+ if (ch.modified) {
+ if (ch.bufferChanged)
+ al.alSourcei (sourceId, AL.AL_BUFFER, ch.bufferId);
+
+ al.alSourcef (sourceId, AL.AL_GAIN, s_volume.value);
+ al.alSourcef (sourceId, AL.AL_ROLLOFF_FACTOR, ch.rolloff);
+ al.alSourcefv(sourceId, AL.AL_POSITION, sourceOrigin);
+ al.alSourcePlay(sourceId);
+ ch.modified = false;
+ } else {
+ state = al.alGetSourcei(ch.sourceId, AL.AL_SOURCE_STATE);
+ if (state == AL.AL_PLAYING) {
+ al.alSourcefv(sourceId, AL.AL_POSITION, sourceOrigin);
+ } else {
+ ch.clear();
+ }
+ }
+ ch.autosound = false;
+ }
+ }
+ }
+
+
+ /* (non-Javadoc)
+ * @see jake2.sound.SoundImpl#StopAllSounds()
+ */
+ public void StopAllSounds() {
+ for (int i = 0; i < MAX_CHANNELS; i++) {
+ al.alSourceStop(sources[i]);
+ al.alSourcei(sources[i], AL.AL_BUFFER, 0);
+ channels[i].clear();
+ }
+ }
+
+ static void convertVector(float[] from, float[] to) {
+ to[0] = from[0];
+ to[1] = from[2];
+ to[2] = -from[1];
+ }
+
+ static void convertOrientation(float[] forward, float[] up, float[] orientation) {
+ orientation[0] = forward[0];
+ orientation[1] = forward[2];
+ orientation[2] = -forward[1];
+ orientation[3] = up[0];
+ orientation[4] = up[2];
+ orientation[5] = -up[1];
+ }
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#getName()
+ */
+ public String getName() {
+ return "joal";
+ }
+
+
+ int s_registration_sequence;
+ boolean s_registering;
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#BeginRegistration()
+ */
+ public void BeginRegistration() {
+ s_registration_sequence++;
+ s_registering = true;
+ }
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#RegisterSound(java.lang.String)
+ */
+ public sfx_t RegisterSound(String name) {
+ sfx_t sfx = FindName(name, true);
+ sfx.registration_sequence = s_registration_sequence;
+
+ if (!s_registering)
+ LoadSound(sfx);
+
+ return sfx;
+ }
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#EndRegistration()
+ */
+ public void EndRegistration() {
+ int i;
+ sfx_t sfx;
+ int size;
+
+ // free any sounds not from this registration sequence
+ for (i = 0; i < num_sfx; i++) {
+ sfx = known_sfx[i];
+ if (sfx.name == null)
+ continue;
+ if (sfx.registration_sequence != s_registration_sequence) {
+ // don't need this sound
+ sfx.clear();
+ }
+ }
+
+ // load everything in
+ for (i = 0; i < num_sfx; i++) {
+ sfx = known_sfx[i];
+ if (sfx.name == null)
+ continue;
+ LoadSound(sfx);
+ }
+
+ s_registering = false;
+ }
+
+ sfx_t RegisterSexedSound(entity_state_t ent, String base) {
+
+ sfx_t sfx = null;
+
+ // determine what model the client is using
+ String model = "male";
+ int n = Globals.CS_PLAYERSKINS + ent.number - 1;
+ if (Globals.cl.configstrings[n] != null) {
+ int p = Globals.cl.configstrings[n].indexOf('\\');
+ if (p >= 0) {
+ p++;
+ model = Globals.cl.configstrings[n].substring(p);
+ //strcpy(model, p);
+ p = model.indexOf('/');
+ if (p > 0)
+ model = model.substring(0, p);
+ }
+ }
+ // if we can't figure it out, they're male
+ if (model == null || model.length() == 0)
+ model = "male";
+
+ // see if we already know of the model specific sound
+ String sexedFilename = "#players/" + model + "/" + base.substring(1);
+ //Com_sprintf (sexedFilename, sizeof(sexedFilename), "#players/%s/%s", model, base+1);
+ sfx = FindName(sexedFilename, false);
+
+ if (sfx == null) {
+ // no, so see if it exists
+ RandomAccessFile f = null;
+ try {
+ f = FS.FOpenFile(sexedFilename.substring(1));
+ } catch (IOException e) {}
+ if (f != null) {
+ // yes, close the file and register it
+ try {
+ FS.FCloseFile(f);
+ } catch (IOException e1) {}
+ sfx = RegisterSound(sexedFilename);
+ } else {
+ // no, revert to the male sound in the pak0.pak
+ //Com_sprintf (maleFilename, sizeof(maleFilename), "player/%s/%s", "male", base+1);
+ String maleFilename = "player/male/" + base.substring(1);
+ sfx = AliasName(sexedFilename, maleFilename);
+ }
+ }
+
+ //System.out.println(sfx.name);
+ return sfx;
+ }
+
+
+ static sfx_t[] known_sfx = new sfx_t[MAX_SFX];
+ static {
+ for (int i = 0; i< known_sfx.length; i++)
+ known_sfx[i] = new sfx_t();
+ }
+ static int num_sfx;
+
+ sfx_t FindName(String name, boolean create) {
+ int i;
+ sfx_t sfx = null;
+
+ if (name == null)
+ Com.Error(Defines.ERR_FATAL, "S_FindName: NULL\n");
+ if (name.length() == 0)
+ Com.Error(Defines.ERR_FATAL, "S_FindName: empty name\n");
+
+ if (name.length() >= Defines.MAX_QPATH)
+ Com.Error(Defines.ERR_FATAL, "Sound name too long: " + name);
+
+ // see if already loaded
+ for (i = 0; i < num_sfx; i++)
+ if (name.equals(known_sfx[i].name)) {
+ return known_sfx[i];
+ }
+
+ if (!create)
+ return null;
+
+ // find a free sfx
+ for (i = 0; i < num_sfx; i++)
+ if (known_sfx[i].name == null)
+ // registration_sequence < s_registration_sequence)
+ break;
+
+ if (i == num_sfx) {
+ if (num_sfx == MAX_SFX)
+ Com.Error(Defines.ERR_FATAL, "S_FindName: out of sfx_t");
+ num_sfx++;
+ }
+
+ sfx = known_sfx[i];
+ sfx.clear();
+ sfx.name = name;
+ sfx.registration_sequence = s_registration_sequence;
+ // cwei
+ sfx.id = i;
+
+ return sfx;
+ }
+
+ /*
+ ==================
+ S_AliasName
+
+ ==================
+ */
+ sfx_t AliasName(String aliasname, String truename)
+ {
+ sfx_t sfx = null;
+ String s;
+ int i;
+
+ s = new String(truename);
+
+ // find a free sfx
+ for (i=0 ; i < num_sfx ; i++)
+ if (known_sfx[i].name == null)
+ break;
+
+ if (i == num_sfx)
+ {
+ if (num_sfx == MAX_SFX)
+ Com.Error(Defines.ERR_FATAL, "S_FindName: out of sfx_t");
+ num_sfx++;
+ }
+
+ sfx = known_sfx[i];
+ sfx.clear();
+ sfx.name = new String(aliasname);
+ sfx.registration_sequence = s_registration_sequence;
+ sfx.truename = s;
+ // cwei
+ sfx.id = i;
+
+ return sfx;
+ }
+
+ /*
+ ==============
+ S_LoadSound
+ ==============
+ */
+ public sfxcache_t LoadSound(sfx_t s) {
+ sfxcache_t sc = WaveLoader.LoadSound(s);
+ initBuffer(s);
+ return sc;
+ }
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#StartLocalSound(java.lang.String)
+ */
+ public void StartLocalSound(String sound) {
+ sfx_t sfx;
+
+ sfx = RegisterSound(sound);
+ if (sfx == null) {
+ Com.Printf("S_StartLocalSound: can't cache " + sound + "\n");
+ return;
+ }
+ StartSound(null, Globals.cl.playernum + 1, 0, sfx, 1, 1, 0);
+ }
+
+ /* (non-Javadoc)
+ * @see jake2.sound.Sound#RawSamples(int, int, int, int, byte[])
+ */
+ public void RawSamples(int samples, int rate, int width, int channels, byte[] data) {
+ // TODO implement RawSamples
+ }
+
+ /*
+ ===============================================================================
+
+ console functions
+
+ ===============================================================================
+ */
+
+ void Play() {
+ int i;
+ String name;
+ sfx_t sfx;
+
+ i = 1;
+ while (i < Cmd.Argc()) {
+ name = new String(Cmd.Argv(i));
+ if (name.indexOf('.') == -1)
+ name += ".wav";
+
+ sfx = RegisterSound(name);
+ StartSound(null, Globals.cl.playernum + 1, 0, sfx, 1.0f, 1.0f, 0.0f);
+ i++;
+ }
+ }
+
+ void SoundList() {
+ int i;
+ sfx_t sfx;
+ sfxcache_t sc;
+ int size, total;
+
+ total = 0;
+ for (i = 0; i < num_sfx; i++) {
+ sfx = known_sfx[i];
+ if (sfx.registration_sequence == 0)
+ continue;
+ sc = sfx.cache;
+ if (sc != null) {
+ size = sc.length * sc.width * (sc.stereo + 1);
+ total += size;
+ if (sc.loopstart >= 0)
+ Com.Printf("L");
+ else
+ Com.Printf(" ");
+ Com.Printf("(%2db) %6i : %s\n", new Vargs(3).add(sc.width * 8).add(size).add(sfx.name));
+ } else {
+ if (sfx.name.charAt(0) == '*')
+ Com.Printf(" placeholder : " + sfx.name + "\n");
+ else
+ Com.Printf(" not loaded : " + sfx.name + "\n");
+ }
+ }
+ Com.Printf("Total resident: " + total + "\n");
+ }
+
+ void SoundInfo_f() {
+
+ Com.Printf("%5d stereo\n", new Vargs(1).add(1));
+ Com.Printf("%5d samples\n", new Vargs(1).add(22050));
+ Com.Printf("%5d samplebits\n", new Vargs(1).add(16));
+ Com.Printf("%5d speed\n", new Vargs(1).add(44100));
+ }
+
+}