aboutsummaryrefslogtreecommitdiffstats
path: root/src/jake2/render/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/jake2/render/common')
-rw-r--r--src/jake2/render/common/Anorms.java220
-rw-r--r--src/jake2/render/common/Base.java97
-rw-r--r--src/jake2/render/common/Draw.java398
-rw-r--r--src/jake2/render/common/GenericGL.java619
-rw-r--r--src/jake2/render/common/Image.java1223
-rw-r--r--src/jake2/render/common/Light.java685
-rw-r--r--src/jake2/render/common/Main.java1181
-rw-r--r--src/jake2/render/common/Mesh.java707
-rw-r--r--src/jake2/render/common/Misc.java58
-rw-r--r--src/jake2/render/common/Model.java1252
-rw-r--r--src/jake2/render/common/Polygon.java164
-rw-r--r--src/jake2/render/common/Surf.java1212
-rw-r--r--src/jake2/render/common/Warp.java676
13 files changed, 8492 insertions, 0 deletions
diff --git a/src/jake2/render/common/Anorms.java b/src/jake2/render/common/Anorms.java
new file mode 100644
index 0000000..e6b9006
--- /dev/null
+++ b/src/jake2/render/common/Anorms.java
@@ -0,0 +1,220 @@
+/*
+ * Anorms.java
+ * Copyright (C) 2003
+ *
+ * $Id: Anorms.java,v 1.1 2006-10-31 13:06:32 salomo 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.common;
+
+/**
+ * Anorms
+ *
+ * @author cwei
+ */
+public class Anorms
+{
+
+ public static 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}
+ };
+
+ public static 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/common/Base.java b/src/jake2/render/common/Base.java
new file mode 100644
index 0000000..9cd2b0f
--- /dev/null
+++ b/src/jake2/render/common/Base.java
@@ -0,0 +1,97 @@
+/*
+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 19.08.2006 by RST.
+// $Id: Base.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+public class Base {
+
+ public static GenericGL ggl;
+
+ // to be initialized!
+ protected int GL_TEXTURE0 = -1;
+ protected int GL_TEXTURE1 = -1;
+ protected int GL_COLOR_INDEX8_EXT = ggl.GL_COLOR_INDEX;
+ public static final String REF_VERSION = "GL 0.01";
+
+
+ // up / down
+ public static final int PITCH = 0;
+ // left / right
+ public static final int YAW = 1;
+ // fall over
+ public static final int ROLL = 2;
+
+ // enum imagetype_t
+ public static final int it_skin = 0;
+ public static final int it_sprite = 1;
+ public static final int it_wall = 2;
+ public static final int it_pic = 3;
+ public static final int it_sky = 4;
+ // enum modtype_t
+ public static final int mod_bad = 0;
+ public static final int mod_brush = 1;
+ public static final int mod_sprite = 2;
+ public static final int mod_alias = 3;
+ public static final int TEXNUM_LIGHTMAPS = 1024;
+ public static final int TEXNUM_SCRAPS = 1152;
+ public static final int TEXNUM_IMAGES = 1153;
+ public static final int MAX_GLTEXTURES = 1024;
+ public static final int MAX_LBM_HEIGHT = 480;
+ public static final float BACKFACE_EPSILON = 0.01f;
+ /*
+ * * GL config stuff
+ */
+ public static final int GL_RENDERER_VOODOO = 0x00000001;
+ public static final int GL_RENDERER_VOODOO2 = 0x00000002;
+ public static final int GL_RENDERER_VOODOO_RUSH = 0x00000004;
+ public static final int GL_RENDERER_BANSHEE = 0x00000008;
+ public static final int GL_RENDERER_3DFX = 0x0000000F;
+ public static final int GL_RENDERER_PCX1 = 0x00000010;
+ public static final int GL_RENDERER_PCX2 = 0x00000020;
+ public static final int GL_RENDERER_PMX = 0x00000040;
+ public static final int GL_RENDERER_POWERVR = 0x00000070;
+ public static final int GL_RENDERER_PERMEDIA2 = 0x00000100;
+ public static final int GL_RENDERER_GLINT_MX = 0x00000200;
+ public static final int GL_RENDERER_GLINT_TX = 0x00000400;
+ public static final int GL_RENDERER_3DLABS_MISC = 0x00000800;
+ public static final int GL_RENDERER_3DLABS = 0x00000F00;
+ public static final int GL_RENDERER_REALIZM = 0x00001000;
+ public static final int GL_RENDERER_REALIZM2 = 0x00002000;
+ public static final int GL_RENDERER_INTERGRAPH = 0x00003000;
+ public static final int GL_RENDERER_3DPRO = 0x00004000;
+ public static final int GL_RENDERER_REAL3D = 0x00008000;
+ public static final int GL_RENDERER_RIVA128 = 0x00010000;
+ public static final int GL_RENDERER_DYPIC = 0x00020000;
+ public static final int GL_RENDERER_V1000 = 0x00040000;
+ public static final int GL_RENDERER_V2100 = 0x00080000;
+ public static final int GL_RENDERER_V2200 = 0x00100000;
+ public static final int GL_RENDERER_RENDITION = 0x001C0000;
+ public static final int GL_RENDERER_O2 = 0x00100000;
+ public static final int GL_RENDERER_IMPACT = 0x00200000;
+ public static final int GL_RENDERER_RE = 0x00400000;
+ public static final int GL_RENDERER_IR = 0x00800000;
+ public static final int GL_RENDERER_SGI = 0x00F00000;
+ public static final int GL_RENDERER_MCD = 0x01000000;
+ public static final int GL_RENDERER_OTHER = 0x80000000;
+
+}
diff --git a/src/jake2/render/common/Draw.java b/src/jake2/render/common/Draw.java
new file mode 100644
index 0000000..b3cb1f4
--- /dev/null
+++ b/src/jake2/render/common/Draw.java
@@ -0,0 +1,398 @@
+/*
+ * Draw.java
+ * Copyright (C) 2003
+ *
+ * $Id: Draw.java,v 1.1 2006-10-31 13:06:32 salomo 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.common;
+
+import jake2.Defines;
+import jake2.client.VID;
+import jake2.qcommon.Com;
+import jake2.render.image_t;
+import jake2.util.Lib;
+
+import java.awt.Dimension;
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+
+/**
+ * Draw
+ * (gl_draw.c)
+ *
+ * @author cwei
+ */
+public abstract class Draw extends Model {
+
+ /*
+ ===============
+ Draw_InitLocal
+ ===============
+ */
+ protected void Draw_InitLocal() {
+ // load console characters (don't bilerp characters)
+ draw_chars = GL_FindImage("pics/conchars.pcx", Base.it_pic);
+ GL_Bind(draw_chars.texnum);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_NEAREST);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.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);
+
+ ggl.glBegin(ggl.GL_QUADS);
+ ggl.glTexCoord2f(fcol, frow);
+ ggl.glVertex2f(x, y);
+ ggl.glTexCoord2f(fcol + size, frow);
+ ggl.glVertex2f(x + 8, y);
+ ggl.glTexCoord2f(fcol + size, frow + size);
+ ggl.glVertex2f(x + 8, y + 8);
+ ggl.glTexCoord2f(fcol, frow + size);
+ ggl.glVertex2f(x, y + 8);
+ ggl.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, Base.it_pic);
+ } else {
+ image = GL_FindImage(name.substring(1), Base.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)
+ {
+ VID.Printf (Defines.PRINT_ALL, "Can't find pic: " + pic +'\n');
+ return;
+ }
+
+ if (scrap_dirty)
+ Scrap_Upload();
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+ ggl.glBegin(ggl.GL_QUADS);
+ ggl.glTexCoord2f(image.sl, image.tl);
+ ggl.glVertex2f(x, y);
+ ggl.glTexCoord2f(image.sh, image.tl);
+ ggl.glVertex2f(x + w, y);
+ ggl.glTexCoord2f(image.sh, image.th);
+ ggl.glVertex2f(x + w, y + h);
+ ggl.glTexCoord2f(image.sl, image.th);
+ ggl.glVertex2f(x, y + h);
+ ggl.glEnd();
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glEnable(ggl.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)
+ {
+ VID.Printf(Defines.PRINT_ALL, "Can't find pic: " +pic + '\n');
+ return;
+ }
+ if (scrap_dirty)
+ Scrap_Upload();
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+
+ ggl.glBegin(ggl.GL_QUADS);
+ ggl.glTexCoord2f(image.sl, image.tl);
+ ggl.glVertex2f(x, y);
+ ggl.glTexCoord2f(image.sh, image.tl);
+ ggl.glVertex2f(x + image.width, y);
+ ggl.glTexCoord2f(image.sh, image.th);
+ ggl.glVertex2f(x + image.width, y + image.height);
+ ggl.glTexCoord2f(image.sl, image.th);
+ ggl.glVertex2f(x, y + image.height);
+ ggl.glEnd();
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glEnable(ggl.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)
+ {
+ VID.Printf(Defines.PRINT_ALL, "Can't find pic: " + pic + '\n');
+ return;
+ }
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+
+ GL_Bind(image.texnum);
+ ggl.glBegin(ggl.GL_QUADS);
+ ggl.glTexCoord2f(x / 64.0f, y / 64.0f);
+ ggl.glVertex2f(x, y);
+ ggl.glTexCoord2f((x + w) / 64.0f, y / 64.0f);
+ ggl.glVertex2f(x + w, y);
+ ggl.glTexCoord2f((x + w) / 64.0f, (y + h) / 64.0f);
+ ggl.glVertex2f(x + w, y + h);
+ ggl.glTexCoord2f(x / 64.0f, (y + h) / 64.0f);
+ ggl.glVertex2f(x, y + h);
+ ggl.glEnd();
+
+ if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ && !image.has_alpha)
+ ggl.glEnable(ggl.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)
+ Com.Error(Defines.ERR_FATAL, "Draw_Fill: bad color");
+
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+
+ int color = d_8to24table[colorIndex];
+
+ ggl.glColor3ub((byte) ((color >> 0) & 0xff), // r
+ (byte) ((color >> 8) & 0xff), // g
+ (byte) ((color >> 16) & 0xff) // b
+ );
+
+ ggl.glBegin(ggl.GL_QUADS);
+
+ ggl.glVertex2f(x, y);
+ ggl.glVertex2f(x + w, y);
+ ggl.glVertex2f(x + w, y + h);
+ ggl.glVertex2f(x, y + h);
+
+ ggl.glEnd();
+ ggl.glColor3f(1, 1, 1);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ }
+
+ // =============================================================================
+
+ /*
+ ================
+ Draw_FadeScreen
+ ================
+ */
+ protected void Draw_FadeScreen() {
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glColor4f(0, 0, 0, 0.8f);
+ ggl.glBegin(ggl.GL_QUADS);
+
+ ggl.glVertex2f(0, 0);
+ ggl.glVertex2f(vid.width, 0);
+ ggl.glVertex2f(vid.width, vid.height);
+ ggl.glVertex2f(0, vid.height);
+
+ ggl.glEnd();
+ ggl.glColor4f(1, 1, 1, 1);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ ggl.glDisable(ggl.GL_BLEND);
+ }
+
+ // ====================================================================
+
+ // allocate a 256 * 256 texture buffer
+ private ByteBuffer image8 = Lib.newByteBuffer(256 * 256 * Defines.SIZE_OF_INT);
+ // share the buffer
+ private IntBuffer image32 = image8.asIntBuffer();
+
+ /*
+ =============
+ 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 destIndex = 0;
+ image32.clear();
+
+ 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.put(destIndex + j, r_rawpalette[data[sourceIndex + (frac >> 16)] & 0xff]);
+ frac += fracstep;
+ }
+ }
+ ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, ggl.GL_RGBA, ggl.GL_UNSIGNED_BYTE, image32);
+ } else {
+ int destIndex = 0;
+ image8.clear();
+
+ 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.put(destIndex + j, data[sourceIndex + (frac >> 16)]);
+ frac += fracstep;
+ }
+ }
+
+ ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, 256, 256, 0, ggl.GL_COLOR_INDEX, ggl.GL_UNSIGNED_BYTE,
+ image8);
+ }
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_LINEAR);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.GL_LINEAR);
+
+
+ if ((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+
+ ggl.glBegin(ggl.GL_QUADS);
+ ggl.glTexCoord2f(0, 0);
+ ggl.glVertex2f(x, y);
+ ggl.glTexCoord2f(1, 0);
+ ggl.glVertex2f(x + w, y);
+ ggl.glTexCoord2f(1, t);
+ ggl.glVertex2f(x + w, y + h);
+ ggl.glTexCoord2f(0, t);
+ ggl.glVertex2f(x, y + h);
+ ggl.glEnd();
+
+ if ((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0))
+ ggl.glEnable(ggl.GL_ALPHA_TEST);
+ }
+}
diff --git a/src/jake2/render/common/GenericGL.java b/src/jake2/render/common/GenericGL.java
new file mode 100644
index 0000000..2d75f17
--- /dev/null
+++ b/src/jake2/render/common/GenericGL.java
@@ -0,0 +1,619 @@
+/*
+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 28.10.2006 by RST.
+
+// $Id: GenericGL.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+import java.nio.*;
+
+/**
+ * This is a class for wrapping lwjgl and jogl GL methods.
+ * It is not known if it performs well, but jit should know what we'Re doing.
+ */
+public interface GenericGL {
+
+ public static final int GL_2_BYTES = 5127;
+ public static final int GL_2D = 1536;
+ public static final int GL_3_BYTES = 5128;
+ public static final int GL_3D = 1537;
+ public static final int GL_3D_COLOR = 1538;
+ public static final int GL_3D_COLOR_TEXTURE = 1539;
+ public static final int GL_4_BYTES = 5129;
+ public static final int GL_4D_COLOR_TEXTURE = 1540;
+ public static final int GL_ACCUM = 256;
+ public static final int GL_ACCUM_ALPHA_BITS = 3419;
+ public static final int GL_ACCUM_BLUE_BITS = 3418;
+ public static final int GL_ACCUM_BUFFER_BIT = 512;
+ public static final int GL_ACCUM_CLEAR_VALUE = 2944;
+ public static final int GL_ACCUM_GREEN_BITS = 3417;
+ public static final int GL_ACCUM_RED_BITS = 3416;
+ public static final int GL_ADD = 260;
+ public static final int GL_ALL_ATTRIB_BITS = 0xfffff;
+ public static final int GL_ALL_CLIENT_ATTRIB_BITS = -1;
+ public static final int GL_ALPHA = 6406;
+ public static final int GL_ALPHA_BIAS = 3357;
+ public static final int GL_ALPHA_BITS = 3413;
+ public static final int GL_ALPHA_SCALE = 3356;
+ public static final int GL_ALPHA_TEST = 3008;
+ public static final int GL_ALPHA_TEST_FUNC = 3009;
+ public static final int GL_ALPHA_TEST_REF = 3010;
+ public static final int GL_ALPHA12 = 32829;
+ public static final int GL_ALPHA16 = 32830;
+ public static final int GL_ALPHA4 = 32827;
+ public static final int GL_ALPHA8 = 32828;
+ public static final int GL_ALWAYS = 519;
+ public static final int GL_AMBIENT = 4608;
+ public static final int GL_AMBIENT_AND_DIFFUSE = 5634;
+ public static final int GL_AND = 5377;
+ public static final int GL_AND_INVERTED = 5380;
+ public static final int GL_AND_REVERSE = 5378;
+ public static final int GL_ATTRIB_STACK_DEPTH = 2992;
+ public static final int GL_AUTO_NORMAL = 3456;
+ public static final int GL_AUX_BUFFERS = 3072;
+ public static final int GL_AUX0 = 1033;
+ public static final int GL_AUX1 = 1034;
+ public static final int GL_AUX2 = 1035;
+ public static final int GL_AUX3 = 1036;
+ public static final int GL_BACK = 1029;
+ public static final int GL_BACK_LEFT = 1026;
+ public static final int GL_BACK_RIGHT = 1027;
+ public static final int GL_BITMAP = 6656;
+ public static final int GL_BITMAP_TOKEN = 1796;
+ public static final int GL_BLEND = 3042;
+ public static final int GL_BLEND_DST = 3040;
+ public static final int GL_BLEND_SRC = 3041;
+ public static final int GL_BLUE = 6405;
+ public static final int GL_BLUE_BIAS = 3355;
+ public static final int GL_BLUE_BITS = 3412;
+ public static final int GL_BLUE_SCALE = 3354;
+ public static final int GL_BYTE = 5120;
+ public static final int GL_C3F_V3F = 10788;
+ public static final int GL_C4F_N3F_V3F = 10790;
+ public static final int GL_C4UB_V2F = 10786;
+ public static final int GL_C4UB_V3F = 10787;
+ public static final int GL_CCW = 2305;
+ public static final int GL_CLAMP = 10496;
+ public static final int GL_CLEAR = 5376;
+ public static final int GL_CLIENT_ATTRIB_STACK_DEPTH = 2993;
+ public static final int GL_CLIENT_PIXEL_STORE_BIT = 1;
+ public static final int GL_CLIENT_VERTEX_ARRAY_BIT = 2;
+ public static final int GL_CLIP_PLANE0 = 12288;
+ public static final int GL_CLIP_PLANE1 = 12289;
+ public static final int GL_CLIP_PLANE2 = 12290;
+ public static final int GL_CLIP_PLANE3 = 12291;
+ public static final int GL_CLIP_PLANE4 = 12292;
+ public static final int GL_CLIP_PLANE5 = 12293;
+ public static final int GL_COEFF = 2560;
+ public static final int GL_COLOR = 6144;
+ public static final int GL_COLOR_ARRAY = 32886;
+ public static final int GL_COLOR_ARRAY_POINTER = 32912;
+ public static final int GL_COLOR_ARRAY_SIZE = 32897;
+ public static final int GL_COLOR_ARRAY_STRIDE = 32899;
+ public static final int GL_COLOR_ARRAY_TYPE = 32898;
+ public static final int GL_COLOR_BUFFER_BIT = 16384;
+ public static final int GL_COLOR_CLEAR_VALUE = 3106;
+ public static final int GL_COLOR_INDEX = 6400;
+ public static final int GL_COLOR_INDEXES = 5635;
+ public static final int GL_COLOR_LOGIC_OP = 3058;
+ public static final int GL_COLOR_MATERIAL = 2903;
+ public static final int GL_COLOR_MATERIAL_FACE = 2901;
+ public static final int GL_COLOR_MATERIAL_PARAMETER = 2902;
+ public static final int GL_COLOR_WRITEMASK = 3107;
+ public static final int GL_COMPILE = 4864;
+ public static final int GL_COMPILE_AND_EXECUTE = 4865;
+ public static final int GL_CONSTANT_ALPHA = 32771;
+ public static final int GL_CONSTANT_ATTENUATION = 4615;
+ public static final int GL_CONSTANT_COLOR = 32769;
+ public static final int GL_COPY = 5379;
+ public static final int GL_COPY_INVERTED = 5388;
+ public static final int GL_COPY_PIXEL_TOKEN = 1798;
+ public static final int GL_CULL_FACE = 2884;
+ public static final int GL_CULL_FACE_MODE = 2885;
+ public static final int GL_CURRENT_BIT = 1;
+ public static final int GL_CURRENT_COLOR = 2816;
+ public static final int GL_CURRENT_INDEX = 2817;
+ public static final int GL_CURRENT_NORMAL = 2818;
+ public static final int GL_CURRENT_RASTER_COLOR = 2820;
+ public static final int GL_CURRENT_RASTER_DISTANCE = 2825;
+ public static final int GL_CURRENT_RASTER_INDEX = 2821;
+ public static final int GL_CURRENT_RASTER_POSITION = 2823;
+ public static final int GL_CURRENT_RASTER_POSITION_VALID = 2824;
+ public static final int GL_CURRENT_RASTER_TEXTURE_COORDS = 2822;
+ public static final int GL_CURRENT_TEXTURE_COORDS = 2819;
+ public static final int GL_CW = 2304;
+ public static final int GL_DECAL = 8449;
+ public static final int GL_DECR = 7683;
+ public static final int GL_DEPTH = 6145;
+ public static final int GL_DEPTH_BIAS = 3359;
+ public static final int GL_DEPTH_BITS = 3414;
+ public static final int GL_DEPTH_BUFFER_BIT = 256;
+ public static final int GL_DEPTH_CLEAR_VALUE = 2931;
+ public static final int GL_DEPTH_COMPONENT = 6402;
+ public static final int GL_DEPTH_FUNC = 2932;
+ public static final int GL_DEPTH_RANGE = 2928;
+ public static final int GL_DEPTH_SCALE = 3358;
+ public static final int GL_DEPTH_TEST = 2929;
+ public static final int GL_DEPTH_WRITEMASK = 2930;
+ public static final int GL_DIFFUSE = 4609;
+ public static final int GL_DITHER = 3024;
+ public static final int GL_DOMAIN = 2562;
+ public static final int GL_DONT_CARE = 4352;
+ public static final int GL_DOUBLE = 5130;
+ public static final int GL_DOUBLEBUFFER = 3122;
+ public static final int GL_DRAW_BUFFER = 3073;
+ public static final int GL_DRAW_PIXEL_TOKEN = 1797;
+ public static final int GL_DST_ALPHA = 772;
+ public static final int GL_DST_COLOR = 774;
+ public static final int GL_EDGE_FLAG = 2883;
+ public static final int GL_EDGE_FLAG_ARRAY = 32889;
+ public static final int GL_EDGE_FLAG_ARRAY_POINTER = 32915;
+ public static final int GL_EDGE_FLAG_ARRAY_STRIDE = 32908;
+ public static final int GL_EMISSION = 5632;
+ public static final int GL_ENABLE_BIT = 8192;
+ public static final int GL_EQUAL = 514;
+ public static final int GL_EQUIV = 5385;
+ public static final int GL_EVAL_BIT = 0x10000;
+ public static final int GL_EXP = 2048;
+ public static final int GL_EXP2 = 2049;
+ public static final int GL_EXTENSIONS = 7939;
+ public static final int GL_EYE_LINEAR = 9216;
+ public static final int GL_EYE_PLANE = 9474;
+ public static final int GL_FALSE = 0;
+ public static final int GL_FASTEST = 4353;
+ public static final int GL_FEEDBACK = 7169;
+ public static final int GL_FEEDBACK_BUFFER_POINTER = 3568;
+ public static final int GL_FEEDBACK_BUFFER_SIZE = 3569;
+ public static final int GL_FEEDBACK_BUFFER_TYPE = 3570;
+ public static final int GL_FILL = 6914;
+ public static final int GL_FLAT = 7424;
+ public static final int GL_FLOAT = 5126;
+ public static final int GL_FOG = 2912;
+ public static final int GL_FOG_BIT = 128;
+ public static final int GL_FOG_COLOR = 2918;
+ public static final int GL_FOG_DENSITY = 2914;
+ public static final int GL_FOG_END = 2916;
+ public static final int GL_FOG_HINT = 3156;
+ public static final int GL_FOG_INDEX = 2913;
+ public static final int GL_FOG_MODE = 2917;
+ public static final int GL_FOG_START = 2915;
+ public static final int GL_FRONT = 1028;
+ public static final int GL_FRONT_AND_BACK = 1032;
+ public static final int GL_FRONT_FACE = 2886;
+ public static final int GL_FRONT_LEFT = 1024;
+ public static final int GL_FRONT_RIGHT = 1025;
+ public static final int GL_GEQUAL = 518;
+ public static final int GL_GREATER = 516;
+ public static final int GL_GREEN = 6404;
+ public static final int GL_GREEN_BIAS = 3353;
+ public static final int GL_GREEN_BITS = 3411;
+ public static final int GL_GREEN_SCALE = 3352;
+ public static final int GL_HINT_BIT = 32768;
+ public static final int GL_INCR = 7682;
+ public static final int GL_INDEX_ARRAY = 32887;
+ public static final int GL_INDEX_ARRAY_POINTER = 32913;
+ public static final int GL_INDEX_ARRAY_STRIDE = 32902;
+ public static final int GL_INDEX_ARRAY_TYPE = 32901;
+ public static final int GL_INDEX_BITS = 3409;
+ public static final int GL_INDEX_CLEAR_VALUE = 3104;
+ public static final int GL_INDEX_LOGIC_OP = 3057;
+ public static final int GL_INDEX_MODE = 3120;
+ public static final int GL_INDEX_OFFSET = 3347;
+ public static final int GL_INDEX_SHIFT = 3346;
+ public static final int GL_INDEX_WRITEMASK = 3105;
+ public static final int GL_INT = 5124;
+ public static final int GL_INTENSITY = 32841;
+ public static final int GL_INTENSITY12 = 32844;
+ public static final int GL_INTENSITY16 = 32845;
+ public static final int GL_INTENSITY4 = 32842;
+ public static final int GL_INTENSITY8 = 32843;
+ public static final int GL_INVALID_ENUM = 1280;
+ public static final int GL_INVALID_OPERATION = 1282;
+ public static final int GL_INVALID_VALUE = 1281;
+ public static final int GL_INVERT = 5386;
+ public static final int GL_KEEP = 7680;
+ public static final int GL_LEFT = 1030;
+ public static final int GL_LEQUAL = 515;
+ public static final int GL_LESS = 513;
+ public static final int GL_LIGHT_MODEL_AMBIENT = 2899;
+ public static final int GL_LIGHT_MODEL_LOCAL_VIEWER = 2897;
+ public static final int GL_LIGHT_MODEL_TWO_SIDE = 2898;
+ public static final int GL_LIGHT0 = 16384;
+ public static final int GL_LIGHT1 = 16385;
+ public static final int GL_LIGHT2 = 16386;
+ public static final int GL_LIGHT3 = 16387;
+ public static final int GL_LIGHT4 = 16388;
+ public static final int GL_LIGHT5 = 16389;
+ public static final int GL_LIGHT6 = 16390;
+ public static final int GL_LIGHT7 = 16391;
+ public static final int GL_LIGHTING = 2896;
+ public static final int GL_LIGHTING_BIT = 64;
+ public static final int GL_LINE = 6913;
+ public static final int GL_LINE_BIT = 4;
+ public static final int GL_LINE_LOOP = 2;
+ public static final int GL_LINE_RESET_TOKEN = 1799;
+ public static final int GL_LINE_SMOOTH = 2848;
+ public static final int GL_LINE_SMOOTH_HINT = 3154;
+ public static final int GL_LINE_STIPPLE = 2852;
+ public static final int GL_LINE_STIPPLE_PATTERN = 2853;
+ public static final int GL_LINE_STIPPLE_REPEAT = 2854;
+ public static final int GL_LINE_STRIP = 3;
+ public static final int GL_LINE_TOKEN = 1794;
+ public static final int GL_LINE_WIDTH = 2849;
+ public static final int GL_LINE_WIDTH_GRANULARITY = 2851;
+ public static final int GL_LINE_WIDTH_RANGE = 2850;
+ public static final int GL_LINEAR = 9729;
+ public static final int GL_LINEAR_ATTENUATION = 4616;
+ public static final int GL_LINEAR_MIPMAP_LINEAR = 9987;
+ public static final int GL_LINEAR_MIPMAP_NEAREST = 9985;
+ public static final int GL_LINES = 1;
+ public static final int GL_LIST_BASE = 2866;
+ public static final int GL_LIST_BIT = 0x20000;
+ public static final int GL_LIST_INDEX = 2867;
+ public static final int GL_LIST_MODE = 2864;
+ public static final int GL_LOAD = 257;
+ public static final int GL_LOGIC_OP = 3057;
+ public static final int GL_LOGIC_OP_MODE = 3056;
+ public static final int GL_LUMINANCE = 6409;
+ public static final int GL_LUMINANCE_ALPHA = 6410;
+ public static final int GL_LUMINANCE12 = 32833;
+ public static final int GL_LUMINANCE12_ALPHA12 = 32839;
+ public static final int GL_LUMINANCE12_ALPHA4 = 32838;
+ public static final int GL_LUMINANCE16 = 32834;
+ public static final int GL_LUMINANCE16_ALPHA16 = 32840;
+ public static final int GL_LUMINANCE4 = 32831;
+ public static final int GL_LUMINANCE4_ALPHA4 = 32835;
+ public static final int GL_LUMINANCE6_ALPHA2 = 32836;
+ public static final int GL_LUMINANCE8 = 32832;
+ public static final int GL_LUMINANCE8_ALPHA8 = 32837;
+ public static final int GL_MAP_COLOR = 3344;
+ public static final int GL_MAP_STENCIL = 3345;
+ public static final int GL_MAP1_COLOR_4 = 3472;
+ public static final int GL_MAP1_GRID_DOMAIN = 3536;
+ public static final int GL_MAP1_GRID_SEGMENTS = 3537;
+ public static final int GL_MAP1_INDEX = 3473;
+ public static final int GL_MAP1_NORMAL = 3474;
+ public static final int GL_MAP1_TEXTURE_COORD_1 = 3475;
+ public static final int GL_MAP1_TEXTURE_COORD_2 = 3476;
+ public static final int GL_MAP1_TEXTURE_COORD_3 = 3477;
+ public static final int GL_MAP1_TEXTURE_COORD_4 = 3478;
+ public static final int GL_MAP1_VERTEX_3 = 3479;
+ public static final int GL_MAP1_VERTEX_4 = 3480;
+ public static final int GL_MAP2_COLOR_4 = 3504;
+ public static final int GL_MAP2_GRID_DOMAIN = 3538;
+ public static final int GL_MAP2_GRID_SEGMENTS = 3539;
+ public static final int GL_MAP2_INDEX = 3505;
+ public static final int GL_MAP2_NORMAL = 3506;
+ public static final int GL_MAP2_TEXTURE_COORD_1 = 3507;
+ public static final int GL_MAP2_TEXTURE_COORD_2 = 3508;
+ public static final int GL_MAP2_TEXTURE_COORD_3 = 3509;
+ public static final int GL_MAP2_TEXTURE_COORD_4 = 3510;
+ public static final int GL_MAP2_VERTEX_3 = 3511;
+ public static final int GL_MAP2_VERTEX_4 = 3512;
+ public static final int GL_MATRIX_MODE = 2976;
+ public static final int GL_MAX_ATTRIB_STACK_DEPTH = 3381;
+ public static final int GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 3387;
+ public static final int GL_MAX_CLIP_PLANES = 3378;
+ public static final int GL_MAX_EVAL_ORDER = 3376;
+ public static final int GL_MAX_LIGHTS = 3377;
+ public static final int GL_MAX_LIST_NESTING = 2865;
+ public static final int GL_MAX_MODELVIEW_STACK_DEPTH = 3382;
+ public static final int GL_MAX_NAME_STACK_DEPTH = 3383;
+ public static final int GL_MAX_PIXEL_MAP_TABLE = 3380;
+ public static final int GL_MAX_PROJECTION_STACK_DEPTH = 3384;
+ public static final int GL_MAX_TEXTURE_SIZE = 3379;
+ public static final int GL_MAX_TEXTURE_STACK_DEPTH = 3385;
+ public static final int GL_MAX_VIEWPORT_DIMS = 3386;
+ public static final int GL_MODELVIEW = 5888;
+ public static final int GL_MODELVIEW_MATRIX = 2982;
+ public static final int GL_MODELVIEW_STACK_DEPTH = 2979;
+ public static final int GL_MODULATE = 8448;
+ public static final int GL_MULT = 259;
+ public static final int GL_N3F_V3F = 10789;
+ public static final int GL_NAME_STACK_DEPTH = 3440;
+ public static final int GL_NAND = 5390;
+ public static final int GL_NEAREST = 9728;
+ public static final int GL_NEAREST_MIPMAP_LINEAR = 9986;
+ public static final int GL_NEAREST_MIPMAP_NEAREST = 9984;
+ public static final int GL_NEVER = 512;
+ public static final int GL_NICEST = 4354;
+ public static final int GL_NO_ERROR = 0;
+ public static final int GL_NONE = 0;
+ public static final int GL_NOOP = 5381;
+ public static final int GL_NOR = 5384;
+ public static final int GL_NORMAL_ARRAY = 32885;
+ public static final int GL_NORMAL_ARRAY_POINTER = 32911;
+ public static final int GL_NORMAL_ARRAY_STRIDE = 32895;
+ public static final int GL_NORMAL_ARRAY_TYPE = 32894;
+ public static final int GL_NORMALIZE = 2977;
+ public static final int GL_NOTEQUAL = 517;
+ public static final int GL_OBJECT_LINEAR = 9217;
+ public static final int GL_OBJECT_PLANE = 9473;
+ public static final int GL_ONE = 1;
+ public static final int GL_ONE_MINUS_CONSTANT_ALPHA = 32772;
+ public static final int GL_ONE_MINUS_CONSTANT_COLOR = 32770;
+ public static final int GL_ONE_MINUS_DST_ALPHA = 773;
+ public static final int GL_ONE_MINUS_DST_COLOR = 775;
+ public static final int GL_ONE_MINUS_SRC_ALPHA = 771;
+ public static final int GL_ONE_MINUS_SRC_COLOR = 769;
+ public static final int GL_OR = 5383;
+ public static final int GL_OR_INVERTED = 5389;
+ public static final int GL_OR_REVERSE = 5387;
+ public static final int GL_ORDER = 2561;
+ public static final int GL_OUT_OF_MEMORY = 1285;
+ public static final int GL_PACK_ALIGNMENT = 3333;
+ public static final int GL_PACK_LSB_FIRST = 3329;
+ public static final int GL_PACK_ROW_LENGTH = 3330;
+ public static final int GL_PACK_SKIP_PIXELS = 3332;
+ public static final int GL_PACK_SKIP_ROWS = 3331;
+ public static final int GL_PACK_SWAP_BYTES = 3328;
+ public static final int GL_PASS_THROUGH_TOKEN = 1792;
+ public static final int GL_PERSPECTIVE_CORRECTION_HINT = 3152;
+ public static final int GL_PIXEL_MAP_A_TO_A = 3193;
+ public static final int GL_PIXEL_MAP_A_TO_A_SIZE = 3257;
+ public static final int GL_PIXEL_MAP_B_TO_B = 3192;
+ public static final int GL_PIXEL_MAP_B_TO_B_SIZE = 3256;
+ public static final int GL_PIXEL_MAP_G_TO_G = 3191;
+ public static final int GL_PIXEL_MAP_G_TO_G_SIZE = 3255;
+ public static final int GL_PIXEL_MAP_I_TO_A = 3189;
+ public static final int GL_PIXEL_MAP_I_TO_A_SIZE = 3253;
+ public static final int GL_PIXEL_MAP_I_TO_B = 3188;
+ public static final int GL_PIXEL_MAP_I_TO_B_SIZE = 3252;
+ public static final int GL_PIXEL_MAP_I_TO_G = 3187;
+ public static final int GL_PIXEL_MAP_I_TO_G_SIZE = 3251;
+ public static final int GL_PIXEL_MAP_I_TO_I = 3184;
+ public static final int GL_PIXEL_MAP_I_TO_I_SIZE = 3248;
+ public static final int GL_PIXEL_MAP_I_TO_R = 3186;
+ public static final int GL_PIXEL_MAP_I_TO_R_SIZE = 3250;
+ public static final int GL_PIXEL_MAP_R_TO_R = 3190;
+ public static final int GL_PIXEL_MAP_R_TO_R_SIZE = 3254;
+ public static final int GL_PIXEL_MAP_S_TO_S = 3185;
+ public static final int GL_PIXEL_MAP_S_TO_S_SIZE = 3249;
+ public static final int GL_PIXEL_MODE_BIT = 32;
+ public static final int GL_POINT = 6912;
+ public static final int GL_POINT_BIT = 2;
+ public static final int GL_POINT_SIZE = 2833;
+ public static final int GL_POINT_SIZE_GRANULARITY = 2835;
+ public static final int GL_POINT_SIZE_RANGE = 2834;
+ public static final int GL_POINT_SMOOTH = 2832;
+ public static final int GL_POINT_SMOOTH_HINT = 3153;
+ public static final int GL_POINT_TOKEN = 1793;
+ public static final int GL_POINTS = 0;
+ public static final int GL_POLYGON = 9;
+ public static final int GL_POLYGON_BIT = 8;
+ public static final int GL_POLYGON_MODE = 2880;
+ public static final int GL_POLYGON_OFFSET_FACTOR = 32824;
+ public static final int GL_POLYGON_OFFSET_FILL = 32823;
+ public static final int GL_POLYGON_OFFSET_LINE = 10754;
+ public static final int GL_POLYGON_OFFSET_POINT = 10753;
+ public static final int GL_POLYGON_OFFSET_UNITS = 10752;
+ public static final int GL_POLYGON_SMOOTH = 2881;
+ public static final int GL_POLYGON_SMOOTH_HINT = 3155;
+ public static final int GL_POLYGON_STIPPLE = 2882;
+ public static final int GL_POLYGON_STIPPLE_BIT = 16;
+ public static final int GL_POLYGON_TOKEN = 1795;
+ public static final int GL_POSITION = 4611;
+ public static final int GL_PROJECTION = 5889;
+ public static final int GL_PROJECTION_MATRIX = 2983;
+ public static final int GL_PROJECTION_STACK_DEPTH = 2980;
+ public static final int GL_PROXY_TEXTURE_1D = 32867;
+ public static final int GL_PROXY_TEXTURE_2D = 32868;
+ public static final int GL_Q = 8195;
+ public static final int GL_QUAD_STRIP = 8;
+ public static final int GL_QUADRATIC_ATTENUATION = 4617;
+ public static final int GL_QUADS = 7;
+ public static final int GL_R = 8194;
+ public static final int GL_R3_G3_B2 = 10768;
+ public static final int GL_READ_BUFFER = 3074;
+ public static final int GL_RED = 6403;
+ public static final int GL_RED_BIAS = 3349;
+ public static final int GL_RED_BITS = 3410;
+ public static final int GL_RED_SCALE = 3348;
+ public static final int GL_RENDER = 7168;
+ public static final int GL_RENDER_MODE = 3136;
+ public static final int GL_RENDERER = 7937;
+ public static final int GL_REPEAT = 10497;
+ public static final int GL_REPLACE = 7681;
+ public static final int GL_RETURN = 258;
+ public static final int GL_RGB = 6407;
+ public static final int GL_RGB10 = 32850;
+ public static final int GL_RGB10_A2 = 32857;
+ public static final int GL_RGB12 = 32851;
+ public static final int GL_RGB16 = 32852;
+ public static final int GL_RGB4 = 32847;
+ public static final int GL_RGB5 = 32848;
+ public static final int GL_RGB5_A1 = 32855;
+ public static final int GL_RGB8 = 32849;
+ public static final int GL_RGBA = 6408;
+ public static final int GL_RGBA_MODE = 3121;
+ public static final int GL_RGBA12 = 32858;
+ public static final int GL_RGBA16 = 32859;
+ public static final int GL_RGBA2 = 32853;
+ public static final int GL_RGBA4 = 32854;
+ public static final int GL_RGBA8 = 32856;
+ public static final int GL_RIGHT = 1031;
+ public static final int GL_S = 8192;
+ public static final int GL_SCISSOR_BIT = 0x80000;
+ public static final int GL_SCISSOR_BOX = 3088;
+ public static final int GL_SCISSOR_TEST = 3089;
+ public static final int GL_SELECT = 7170;
+ public static final int GL_SELECTION_BUFFER_POINTER = 3571;
+ public static final int GL_SELECTION_BUFFER_SIZE = 3572;
+ public static final int GL_SET = 5391;
+ public static final int GL_SHADE_MODEL = 2900;
+ public static final int GL_SHININESS = 5633;
+ public static final int GL_SHORT = 5122;
+ public static final int GL_SMOOTH = 7425;
+ public static final int GL_SPECULAR = 4610;
+ public static final int GL_SPHERE_MAP = 9218;
+ public static final int GL_SPOT_CUTOFF = 4614;
+ public static final int GL_SPOT_DIRECTION = 4612;
+ public static final int GL_SPOT_EXPONENT = 4613;
+ public static final int GL_SRC_ALPHA = 770;
+ public static final int GL_SRC_ALPHA_SATURATE = 776;
+ public static final int GL_SRC_COLOR = 768;
+ public static final int GL_STACK_OVERFLOW = 1283;
+ public static final int GL_STACK_UNDERFLOW = 1284;
+ public static final int GL_STENCIL = 6146;
+ public static final int GL_STENCIL_BITS = 3415;
+ public static final int GL_STENCIL_BUFFER_BIT = 1024;
+ public static final int GL_STENCIL_CLEAR_VALUE = 2961;
+ public static final int GL_STENCIL_FAIL = 2964;
+ public static final int GL_STENCIL_FUNC = 2962;
+ public static final int GL_STENCIL_INDEX = 6401;
+ public static final int GL_STENCIL_PASS_DEPTH_FAIL = 2965;
+ public static final int GL_STENCIL_PASS_DEPTH_PASS = 2966;
+ public static final int GL_STENCIL_REF = 2967;
+ public static final int GL_STENCIL_TEST = 2960;
+ public static final int GL_STENCIL_VALUE_MASK = 2963;
+ public static final int GL_STENCIL_WRITEMASK = 2968;
+ public static final int GL_STEREO = 3123;
+ public static final int GL_SUBPIXEL_BITS = 3408;
+ public static final int GL_T = 8193;
+ public static final int GL_T2F_C3F_V3F = 10794;
+ public static final int GL_T2F_C4F_N3F_V3F = 10796;
+ public static final int GL_T2F_C4UB_V3F = 10793;
+ public static final int GL_T2F_N3F_V3F = 10795;
+ public static final int GL_T2F_V3F = 10791;
+ public static final int GL_T4F_C4F_N3F_V4F = 10797;
+ public static final int GL_T4F_V4F = 10792;
+ public static final int GL_TEXTURE = 5890;
+ public static final int GL_TEXTURE_1D = 3552;
+ public static final int GL_TEXTURE_2D = 3553;
+ public static final int GL_TEXTURE_ALPHA_SIZE = 32863;
+ public static final int GL_TEXTURE_BINDING_1D = 32872;
+ public static final int GL_TEXTURE_BINDING_2D = 32873;
+ public static final int GL_TEXTURE_BIT = 0x40000;
+ public static final int GL_TEXTURE_BLUE_SIZE = 32862;
+ public static final int GL_TEXTURE_BORDER = 4101;
+ public static final int GL_TEXTURE_BORDER_COLOR = 4100;
+ public static final int GL_TEXTURE_COMPONENTS = 4099;
+ public static final int GL_TEXTURE_COORD_ARRAY = 32888;
+ public static final int GL_TEXTURE_COORD_ARRAY_POINTER = 32914;
+ public static final int GL_TEXTURE_COORD_ARRAY_SIZE = 32904;
+ public static final int GL_TEXTURE_COORD_ARRAY_STRIDE = 32906;
+ public static final int GL_TEXTURE_COORD_ARRAY_TYPE = 32905;
+ public static final int GL_TEXTURE_ENV = 8960;
+ public static final int GL_TEXTURE_ENV_COLOR = 8705;
+ public static final int GL_TEXTURE_ENV_MODE = 8704;
+ public static final int GL_TEXTURE_GEN_MODE = 9472;
+ public static final int GL_TEXTURE_GEN_Q = 3171;
+ public static final int GL_TEXTURE_GEN_R = 3170;
+ public static final int GL_TEXTURE_GEN_S = 3168;
+ public static final int GL_TEXTURE_GEN_T = 3169;
+ public static final int GL_TEXTURE_GREEN_SIZE = 32861;
+ public static final int GL_TEXTURE_HEIGHT = 4097;
+ public static final int GL_TEXTURE_INTENSITY_SIZE = 32865;
+ public static final int GL_TEXTURE_INTERNAL_FORMAT = 4099;
+ public static final int GL_TEXTURE_LUMINANCE_SIZE = 32864;
+ public static final int GL_TEXTURE_MAG_FILTER = 10240;
+ public static final int GL_TEXTURE_MATRIX = 2984;
+ public static final int GL_TEXTURE_MIN_FILTER = 10241;
+ public static final int GL_TEXTURE_PRIORITY = 32870;
+ public static final int GL_TEXTURE_RED_SIZE = 32860;
+ public static final int GL_TEXTURE_RESIDENT = 32871;
+ public static final int GL_TEXTURE_STACK_DEPTH = 2981;
+ public static final int GL_TEXTURE_WIDTH = 4096;
+ public static final int GL_TEXTURE_WRAP_S = 10242;
+ public static final int GL_TEXTURE_WRAP_T = 10243;
+ public static final int GL_TRANSFORM_BIT = 4096;
+ public static final int GL_TRIANGLE_FAN = 6;
+ public static final int GL_TRIANGLE_STRIP = 5;
+ public static final int GL_TRIANGLES = 4;
+ public static final int GL_TRUE = 1;
+ public static final int GL_UNPACK_ALIGNMENT = 3317;
+ public static final int GL_UNPACK_LSB_FIRST = 3313;
+ public static final int GL_UNPACK_ROW_LENGTH = 3314;
+ public static final int GL_UNPACK_SKIP_PIXELS = 3316;
+ public static final int GL_UNPACK_SKIP_ROWS = 3315;
+ public static final int GL_UNPACK_SWAP_BYTES = 3312;
+ public static final int GL_UNSIGNED_BYTE = 5121;
+ public static final int GL_UNSIGNED_INT = 5125;
+ public static final int GL_UNSIGNED_SHORT = 5123;
+ public static final int GL_V2F = 10784;
+ public static final int GL_V3F = 10785;
+ public static final int GL_VENDOR = 7936;
+ public static final int GL_VERSION = 7938;
+ public static final int GL_VERTEX_ARRAY = 32884;
+ public static final int GL_VERTEX_ARRAY_POINTER = 32910;
+ public static final int GL_VERTEX_ARRAY_SIZE = 32890;
+ public static final int GL_VERTEX_ARRAY_STRIDE = 32892;
+ public static final int GL_VERTEX_ARRAY_TYPE = 32891;
+ public static final int GL_VIEWPORT = 2978;
+ public static final int GL_VIEWPORT_BIT = 2048;
+ public static final int GL_XOR = 5382;
+ public static final int GL_ZERO = 0;
+ public static final int GL_ZOOM_X = 3350;
+ public static final int GL_ZOOM_Y = 3351;
+
+
+ void glActiveTextureARB(int texture);
+ void glBegin(int gl_triangle_fan2);
+ void glBindTexture(int gl_texture_2d2, int texnum);
+ void glBlendFunc(int gl_src_alpha2, int gl_one_minus_src_alpha2);
+ void glClear(int gl_color_buffer_bit2);
+ void glClearColor(float f, float g, float h, float i);
+ void glClientActiveTextureARB(int texture);
+ void glColor3f(float f, float g, float h);
+ void glColor3ub(byte b, byte c, byte d);
+ void glColor4f(float intens, float intens2, float intens3, float f);
+ void glColor4f(int i, int j, int k, float f);
+ void glColor4ub(byte b, byte c, byte d, byte e);
+ void glColorPointer(int i, int gl_float2, int j, FloatBuffer colorArrayBuf);
+ void glColorPointer(int i, int gl_unsigned_byte2, int j, ByteBuffer bb);
+ void glCullFace(int gl_back2);
+ void glDepthFunc(int gl_lequal2);
+ void glDepthMask(boolean b);
+ void glDepthRange(float gldepthmin, double d);
+ void glDisable(int gl_texture_2d2);
+ void glDisableClientState(int gl_color_array2);
+ void glDrawArrays(int gl_polygon2, int pos, int numverts);
+ void glDrawElements(int mode, int count, int gl_unsigned_int2, IntBuffer srcIndexBuf);
+ void glEnable(int gl_alpha_test2);
+ void glEnableClientState(int gl_color_array2);
+ void glEnd();
+ void glFrustum(double xmin, double xmax, double ymin, double ymax, double near, double far);
+ void glInterleavedArrays(int gl_t2f_v3f2, int byte_stride, FloatBuffer globalPolygonInterleavedBuf);
+ void glLoadIdentity();
+ void glLoadMatrixf(float[] r_world_matrix);
+ void glMatrixMode(int gl_projection2);
+ void glOrtho(int i, int width, int height, int j, int k, int l);
+ void glPointSize(float value);
+ void glPopMatrix();
+ void glPushMatrix();
+ void glRotatef(float f, float g, float h, float i);
+ void glScalef(int i, int j, int k);
+ void glShadeModel(int gl_smooth2);
+ void glTexCoord2f(float s, float t);
+ void glTexCoordPointer(int i, int gl_float2, int j, FloatBuffer textureArrayBuf);
+ void glTexEnvi(int gl_texture_env2, int gl_texture_env_mode2, int mode);
+ void glTexImage2D(int gl_texture_2d2, int i, int gl_color_index8_ext, int j, int k, int l, int gl_color_index2, int gl_unsigned_byte2, ByteBuffer image8);
+ void glTexImage2D(int gl_texture_2d2, int i, int gl_tex_solid_format, int j, int k, int l, int gl_rgba3, int gl_unsigned_byte2, IntBuffer image32);
+ void glTexParameterf(int gl_texture_2d, int gl_texture_min_filter, int gl_nearest);
+ void glTexParameteri(int gl_texture_2d2, int gl_texture_min_filter2, int gl_filter_min);
+ void glTexSubImage2D(int gl_texture_2d2, int i, int j, int k, int lm_block_width, int height, int gl_lightmap_format, int gl_unsigned_byte2, IntBuffer lightmap_buffer);
+ void glTranslatef(float f, float g, float h);
+ void glVertex2f(int x, int i);
+ void glVertex3f(float f, float g, float h);
+ void glVertexPointer(int i, int gl_float2, int j, FloatBuffer vertexArrayBuf);
+ void glViewport(int i, int j, int width, int height);
+}
diff --git a/src/jake2/render/common/Image.java b/src/jake2/render/common/Image.java
new file mode 100644
index 0000000..f9a9546
--- /dev/null
+++ b/src/jake2/render/common/Image.java
@@ -0,0 +1,1223 @@
+/*
+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 20.08.2006 by RST.
+
+// $Id: Image.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import jake2.Defines;
+import jake2.client.VID;
+import jake2.client.particle_t;
+import jake2.game.cvar_t;
+import jake2.qcommon.*;
+import jake2.render.image_t;
+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.ByteBuffer;
+
+
+public abstract class Image extends Main {
+
+ public static class pos_t {
+ public int x, y;
+
+ public pos_t(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+ }
+
+ public static class floodfill_t {
+ public short x, y;
+ }
+
+ protected static final int MAX_SCRAPS = 1;
+
+ protected static final int BLOCK_WIDTH = 256;
+
+ protected static final int BLOCK_HEIGHT = 256;
+
+ protected int[][] scrap_allocated = new int[MAX_SCRAPS][BLOCK_WIDTH];
+
+ protected byte[][] scrap_texels = new byte[MAX_SCRAPS][BLOCK_WIDTH * BLOCK_HEIGHT];
+
+ protected boolean scrap_dirty;
+
+ // must be a power of 2
+ protected static final int FLOODFILL_FIFO_SIZE = 0x1000;
+
+ protected static final int FLOODFILL_FIFO_MASK = FLOODFILL_FIFO_SIZE - 1;
+
+ protected static floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE];
+ static {
+ for (int j = 0; j < fifo.length; j++) {
+ fifo[j] = new floodfill_t();
+ }
+ }
+
+
+ // gltmode_t
+ public static class gltmode_t {
+
+ public String name;
+ public int mode;
+
+ public gltmode_t(String name, int mode) {
+ this.name = name;
+ this.mode = mode;
+ }
+ }
+
+ // glmode_t
+ public static class glmode_t {
+
+ public String name;
+ public int minimize, maximize;
+
+ public glmode_t(String name, int minimize, int maximze) {
+ this.name = name;
+ this.minimize = minimize;
+ this.maximize = maximze;
+ }
+ }
+
+ protected glmode_t[] getGLModes()
+ {
+ return new glmode_t[]{
+ new glmode_t("GL_NEAREST", ggl.GL_NEAREST, ggl.GL_NEAREST),
+ new glmode_t("GL_LINEAR", ggl.GL_LINEAR, ggl.GL_LINEAR),
+ new glmode_t("GL_NEAREST_MIPMAP_NEAREST",
+ ggl.GL_NEAREST_MIPMAP_NEAREST, ggl.GL_NEAREST),
+ new glmode_t("GL_LINEAR_MIPMAP_NEAREST",
+ ggl.GL_LINEAR_MIPMAP_NEAREST, ggl.GL_LINEAR),
+ new glmode_t("GL_NEAREST_MIPMAP_LINEAR",
+ ggl.GL_NEAREST_MIPMAP_LINEAR, ggl.GL_NEAREST),
+ new glmode_t("GL_LINEAR_MIPMAP_LINEAR", ggl.GL_LINEAR_MIPMAP_LINEAR,
+ ggl.GL_LINEAR) };
+ }
+
+
+ protected gltmode_t[] getGLAlphaModes()
+ {
+ return new gltmode_t[] {
+ new gltmode_t("default", 4),
+ new gltmode_t("GL_RGBA", ggl.GL_RGBA),
+ new gltmode_t("GL_RGBA8", ggl.GL_RGBA8),
+ new gltmode_t("GL_RGB5_A1", ggl.GL_RGB5_A1),
+ new gltmode_t("GL_RGBA4", ggl.GL_RGBA4),
+ new gltmode_t("GL_RGBA2", ggl.GL_RGBA2)
+ };
+ }
+
+ protected gltmode_t[] getGLSolidModes()
+ {
+ return new gltmode_t[] {
+ new gltmode_t("default", 3),
+ new gltmode_t("GL_RGB", ggl.GL_RGB),
+ new gltmode_t("GL_RGB8", ggl.GL_RGB8),
+ new gltmode_t("GL_RGB5", ggl.GL_RGB5),
+ new gltmode_t("GL_RGB4", ggl.GL_RGB4),
+ new gltmode_t("GL_R3_G3_B2", ggl.GL_R3_G3_B2),
+ //new gltmode_t("GL_RGB2", GL.GL_RGB2_EXT);
+ };
+ }
+
+ protected image_t draw_chars;
+
+ protected image_t[] gltextures = new image_t[MAX_GLTEXTURES];
+
+ protected int numgltextures;
+
+ protected int base_textureid; // gltextures[i] = base_textureid+i
+
+ protected byte[] intensitytable = new byte[256];
+
+ protected byte[] gammatable = new byte[256];
+
+ protected cvar_t intensity;
+
+ public Image() {
+ // init the texture cache
+ for (int i = 0; i < gltextures.length; i++) {
+ gltextures[i] = new image_t(i);
+ }
+ numgltextures = 0;
+ }
+
+ protected int gl_solid_format = 3;
+ protected int gl_alpha_format = 4;
+ protected int gl_tex_solid_format = 3;
+ protected int gl_tex_alpha_format = 4;
+
+ protected int gl_filter_min = ggl.GL_LINEAR_MIPMAP_NEAREST;
+ protected int gl_filter_max = ggl.GL_LINEAR;
+
+ protected int upload_width, upload_height;
+
+ protected boolean uploaded_paletted;
+
+
+ /**
+ * GL_TextureAlphaMode
+ */
+ protected void GL_TextureAlphaMode(String string) {
+
+ int i;
+
+ gltmode_t [] gl_alpha_modes = getGLAlphaModes();
+
+ for (i = 0; i < gl_alpha_modes.length ; i++) {
+ if (gl_alpha_modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == gl_alpha_modes.length) {
+ VID.Printf(Defines.PRINT_ALL, "bad alpha texture mode name: [" + string + "]\n");
+ return;
+ }
+
+ gl_tex_alpha_format = gl_alpha_modes[i].mode;
+ }
+
+ /**
+ * GL_TextureSolidMode
+ */
+ protected void GL_TextureSolidMode(String string) {
+
+ int i;
+
+ gltmode_t [] gl_solid_modes = getGLAlphaModes();
+
+ for (i = 0; i < gl_solid_modes.length; i++) {
+ if (gl_solid_modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == gl_solid_modes.length) {
+ VID.Printf(Defines.PRINT_ALL, "bad solid texture mode name: [" + string + "]\n");
+ return;
+ }
+
+ gl_tex_solid_format = gl_solid_modes[i].mode;
+ }
+
+ /**
+ * GL_TextureMode
+ */
+ protected void GL_TextureMode(String string) {
+
+ int i;
+ glmode_t modes [] = getGLModes();
+ for (i = 0; i < modes.length; i++) {
+ if (modes[i].name.equalsIgnoreCase(string))
+ break;
+ }
+
+ if (i == modes.length) {
+ VID.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);
+ ggl.glTexParameteri(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, gl_filter_min);
+ ggl.glTexParameteri(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ }
+ }
+ }
+
+
+ protected void GL_EnableMultitexture(boolean enable) {
+ if (enable) {
+ GL_SelectTexture(GL_TEXTURE1);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ GL_TexEnv(ggl.GL_REPLACE);
+ } else {
+ GL_SelectTexture(GL_TEXTURE1);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ GL_TexEnv(ggl.GL_REPLACE);
+ }
+ GL_SelectTexture(GL_TEXTURE0);
+ GL_TexEnv(ggl.GL_REPLACE);
+ }
+
+ protected void GL_SelectTexture(int texture) {
+ int tmu;
+
+ tmu = (texture == GL_TEXTURE0) ? 0 : 1;
+
+ if (tmu == gl_state.currenttmu) {
+ return;
+ }
+
+ gl_state.currenttmu = tmu;
+
+ ggl.glActiveTextureARB(texture);
+ ggl.glClientActiveTextureARB(texture);
+ }
+
+ int[] lastmodes = { -1, -1 };
+
+ protected void GL_TexEnv(int mode) {
+
+ if (mode != lastmodes[gl_state.currenttmu]) {
+ ggl.glTexEnvi(ggl.GL_TEXTURE_ENV, ggl.GL_TEXTURE_ENV_MODE, mode);
+ lastmodes[gl_state.currenttmu] = mode;
+ }
+ }
+
+ /**
+ * GL_ImageList_f
+ */
+ protected void GL_ImageList_f() {
+
+ image_t image;
+ int texels;
+ final String[] palstrings = { "RGB", "PAL" };
+
+ VID.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:
+ VID.Printf(Defines.PRINT_ALL, "M");
+ break;
+ case it_sprite:
+ VID.Printf(Defines.PRINT_ALL, "S");
+ break;
+ case it_wall:
+ VID.Printf(Defines.PRINT_ALL, "W");
+ break;
+ case it_pic:
+ VID.Printf(Defines.PRINT_ALL, "P");
+ break;
+ default:
+ VID.Printf(Defines.PRINT_ALL, " ");
+ break;
+ }
+
+ VID.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));
+ }
+ VID.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
+ *
+ * =============================================================================
+ */
+
+
+ /**
+ * Returns a texture number and the position inside it.
+ */
+ protected 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;
+ }
+
+ /**
+ * Mod_FloodFillSkin
+ *
+ * Fill background pixels so mipmapping doesn't have haloes
+ */
+
+ // TODO check this
+ protected void R_FloodFillSkin(byte[] skin, int skinwidth, int skinheight) {
+ // assume this is the pixel to fill
+ int fillcolor = skin[0] & 0xFF;
+ int inpt = 0, outpt = 0;
+ int filledcolor = -1;
+ int i;
+
+
+ if (filledcolor == -1) {
+ filledcolor = 0;
+ // attempt to find opaque black
+ for (i = 0; i < 256; ++i)
+ if (d_8to24table[i] == 0xFF000000) { // 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;
+ 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, simplified by cwei.
+ */
+ protected void GL_ResampleTexture(int[] in, int inwidth, int inheight, int[] out,
+ int outwidth, int outheight) {
+
+ 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);
+ }
+
+ /**
+ * GL_LightScaleTexture, Scale up the pixel values in a texture to increase the lighting range.
+ */
+ protected 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
+ */
+ protected 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_InitImages
+ */
+ protected void GL_InitImages() {
+ int i, j;
+ float g = vid_gamma.value;
+
+ registration_sequence = 1;
+
+ // init intensity conversions
+ intensity = Cvar.Get("intensity", "2", 0);
+
+ if (intensity.value <= 1)
+ Cvar.Set("intensity", "1");
+
+ gl_state.inverse_intensity = 1 / intensity.value;
+
+ Draw_GetPalette();
+
+ if (qglColorTableEXT) {
+ gl_state.d_16to8table = FS.LoadFile("pics/16to8.dat");
+ if (gl_state.d_16to8table == null)
+ Com.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_LoadPic
+ * This is also used as an entry point for the generated r_notexture.
+ */
+ protected 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)
+ Com.Error(Defines.ERR_DROP, "MAX_GLTEXTURES");
+
+ numgltextures++;
+ }
+ image = gltextures[i];
+
+ if (name.length() > Defines.MAX_QPATH)
+ Com.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;
+ }
+
+
+ /**
+ * LoadPCX
+ */
+ protected byte[] LoadPCX(String filename, byte[][] palette, Dimension dim) {
+ qfiles.pcx_t pcx;
+
+ //
+ // load the file
+ //
+ byte[] raw = FS.LoadFile(filename);
+
+ if (raw == null) {
+ VID.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) {
+
+ VID.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;
+ }
+
+ protected Throwable gotoBreakOut = new Throwable();
+
+ protected Throwable gotoDone = gotoBreakOut;
+
+ // /*
+ // =========================================================
+ //
+ // TARGA LOADING
+ //
+ // =========================================================
+ // */
+
+
+ /**
+ * LoadTGA
+ */
+ protected byte[] LoadTGA(String name, Dimension dim) {
+ int columns, rows, numPixels;
+ int pixbuf; // index into pic
+ int row, column;
+ byte[] raw;
+ ByteBuffer buf_p;
+ qfiles.tga_t targa_header;
+ byte[] pic = null;
+
+ //
+ // load the file
+ //
+ raw = FS.LoadFile(name);
+
+ if (raw == null) {
+ VID.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)
+ Com.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))
+ Com.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 gotoBreakOut;
+
+ 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 gotoBreakOut;
+
+ pixbuf = row * columns * 4;
+ }
+ }
+ }
+ }
+ } catch (Throwable e) {
+ // label breakOut:
+ }
+ }
+ }
+ return pic;
+ }
+
+ /**
+ * GL_LoadWal
+ */
+ protected image_t GL_LoadWal(String name) {
+
+ image_t image = null;
+
+ byte[] raw = FS.LoadFile(name);
+ if (raw == null) {
+ VID.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.
+ */
+ protected 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;
+
+ // 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
+ //
+ image = null;
+ 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);
+
+ }
+
+ return image;
+ }
+
+ /**
+ * R_RegisterSkin
+ */
+ protected image_t R_RegisterSkin(String name) {
+ return GL_FindImage(name, it_skin);
+ }
+
+ /**
+ * Draw_GetPalettes
+ */
+ protected void Draw_GetPalette() {
+ int r, g, b;
+ byte[] pic;
+ byte[][] palette = new byte[1][]; // new byte[768];
+
+ // get the palette
+ pic = LoadPCX("pics/colormap.pcx", palette, new Dimension());
+
+ if (pic == null || palette[0] == null || palette[0].length != 768)
+ Com.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_BuildPalettedTexture.
+ */
+ protected 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];
+ }
+ }
+
+ protected 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;
+ ggl.glBindTexture(ggl.GL_TEXTURE_2D, texnum);
+ }
+
+ int scrap_uploads = 0;
+
+
+ protected void Scrap_Upload() {
+ scrap_uploads++;
+ GL_Bind(TEXNUM_SCRAPS);
+ GL_Upload8(scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, false);
+ scrap_dirty = false;
+ }
+
+
+ protected void GL_MBind(int target, 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);
+ }
+}
diff --git a/src/jake2/render/common/Light.java b/src/jake2/render/common/Light.java
new file mode 100644
index 0000000..5781975
--- /dev/null
+++ b/src/jake2/render/common/Light.java
@@ -0,0 +1,685 @@
+/*
+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 20.08.2006 by RST.
+
+// $Id: Light.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.util.Arrays;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+import jake2.util.Math3D;
+import jake2.util.Vec3Cache;
+
+public abstract class Light extends Warp {
+
+ protected float[] pointcolor = { 0, 0, 0 }; // vec3_t
+
+ protected cplane_t lightplane; // used as shadow plane
+
+ protected float[] lightspot = { 0, 0, 0 }; // vec3_t
+
+ protected float[] s_blocklights = new float[34 * 34 * 3];
+
+ protected int r_dlightframecount;
+
+ protected final float[] impact = { 0, 0, 0 };
+
+
+ public static final int DLIGHT_CUTOFF = 64;
+
+ /**
+ * R_AddDynamicLights
+ */
+ protected void R_AddDynamicLights(msurface_t surf) {
+ int sd, td;
+ float fdist, frad, fminlight;
+ int s, t;
+ dlight_t dl;
+ float[] pfBL;
+ float fsacc, ftacc;
+
+ int smax = (surf.extents[0] >> 4) + 1;
+ int tmax = (surf.extents[1] >> 4) + 1;
+ mtexinfo_t tex = surf.texinfo;
+
+ float local0, local1;
+ for (int 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 (int i = 0; i < 3; i++) {
+ impact[i] = dl.origin[i] - surf.plane.normal[i] * fdist;
+ }
+
+ local0 = Math3D.DotProduct(impact, tex.vecs[0]) + tex.vecs[0][3]
+ - surf.texturemins[0];
+ local1 = 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) (local1 - ftacc);
+ if (td < 0)
+ td = -td;
+
+ for (s = 0, fsacc = 0; s < smax; s++, fsacc += 16, pfBLindex += 3) {
+ sd = (int) (local0 - 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];
+ }
+ }
+ }
+ }
+ }
+
+ // replaces the goto jump
+ private Throwable gotoStore = new Throwable();
+
+ /**
+ * R_BuildLightMap
+ *
+ * Combine and scale multiple lightmaps into the floating format in
+ * blocklights
+ */
+
+ protected void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride) {
+ int r, g, b, a, max;
+ int i, j;
+ int nummaps;
+ float[] bl;
+ // lightstyle_t style;
+
+ if ((surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33
+ | Defines.SURF_TRANS66 | Defines.SURF_WARP)) != 0)
+ Com.Error(Defines.ERR_DROP,
+ "R_BuildLightMap called for non-lit surface");
+
+ int smax = (surf.extents[0] >> 4) + 1;
+ int tmax = (surf.extents[1] >> 4) + 1;
+ int size = smax * tmax;
+ if (size > ((s_blocklights.length * Defines.SIZE_OF_FLOAT) >> 4))
+ Com.Error(Defines.ERR_DROP, "Bad s_blocklights size");
+
+ try {
+ // set to full bright if no light data
+ if (surf.samples == null) {
+
+ for (i = 0; i < size * 3; i++)
+ s_blocklights[i] = 255;
+
+ // goto store;
+ throw gotoStore;
+ }
+
+ // count the # of maps
+ for (nummaps = 0; nummaps < Defines.MAXLIGHTMAPS
+ && surf.styles[nummaps] != (byte) 255; nummaps++);
+
+ ByteBuffer lightmap = surf.samples;
+ int lightmapIndex = 0;
+
+ // add all the lightmaps
+ float scale0;
+ float scale1;
+ float scale2;
+ 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];
+
+ scale0 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0];
+ scale1 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1];
+ scale2 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2];
+
+ if (scale0 == 1.0F && scale1 == 1.0F && scale2 == 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) * scale0;
+ bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale1;
+ bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale2;
+ }
+ }
+ // lightmap += size*3; // skip to next lightmap
+ }
+ } else {
+ int maps;
+
+ 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];
+ scale0 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0];
+ scale1 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1];
+ scale2 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2];
+
+ if (scale0 == 1.0F && scale1 == 1.0F && scale2 == 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) * scale0;
+ bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale1;
+ bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale2;
+ }
+ }
+ // lightmap += size*3; // skip to next lightmap
+ }
+ }
+
+ // add all the dynamic lights
+ if (surf.dlightframe == r_framecount)
+ R_AddDynamicLights(surf);
+
+ // label store:
+ } catch (Throwable store) {
+ }
+
+ // put into texture format
+ stride -= smax;
+ bl = s_blocklights;
+ int blp = 0;
+
+ int 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);
+ }
+ }
+ } 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);
+ float af = a / 255.0f;
+ r *= af;
+ g *= af;
+ b *= af;
+ 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);
+ }
+ }
+ }
+ }
+
+
+ // stack variable
+ private final float[] end = { 0, 0, 0 };
+
+ /**
+ * R_LightPoint
+ */
+ protected void R_LightPoint(float[] p, float[] color) {
+ assert (p.length == 3) : "vec3_t bug";
+ assert (color.length == 3) : "rgb bug";
+
+ 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;
+
+ float r = RecursiveLightPoint(r_worldmodel.nodes[0], p, end);
+
+ if (r == -1) {
+ Math3D.VectorCopy(Globals.vec3_origin, color);
+ } else {
+ Math3D.VectorCopy(pointcolor, color);
+ }
+
+ //
+ // add dynamic lights
+ //
+ dlight_t dl;
+ float add;
+ for (int lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) {
+ dl = r_newrefdef.dlights[lnum];
+
+ Math3D.VectorSubtract(currententity.origin, dl.origin, end);
+ add = dl.intensity - Math3D.VectorLength(end);
+ add *= (1.0f / 256);
+ if (add > 0) {
+ Math3D.VectorMA(color, add, dl.color, color);
+ }
+ }
+ Math3D.VectorScale(color, gl_modulate.value, color);
+ }
+
+ /**
+ * RecursiveLightPoint
+ *
+ * @param node
+ * @param start
+ * @param end
+ * @return
+ */
+ protected int RecursiveLightPoint(mnode_t node, float[] start, float[] end) {
+ if (node.contents != -1)
+ return -1; // didn't hit anything
+
+ // calculate mid point
+
+ // FIXME: optimize for axial
+ cplane_t plane = node.plane;
+ float front = Math3D.DotProduct(start, plane.normal) - plane.dist;
+ float back = Math3D.DotProduct(end, plane.normal) - plane.dist;
+ boolean side = (front < 0);
+ int sideIndex = (side) ? 1 : 0;
+
+ if ((back < 0) == side)
+ return RecursiveLightPoint(node.children[sideIndex], start, end);
+
+ float frac = front / (front - back);
+ float[] mid = Vec3Cache.get();
+ 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
+ int r = RecursiveLightPoint(node.children[sideIndex], start, mid);
+ if (r >= 0) {
+ Vec3Cache.release(); // mid
+ return r; // hit something
+ }
+
+ if ((back < 0) == side) {
+ Vec3Cache.release(); // mid
+ return -1; // didn't hit anuthing
+ }
+
+ // check for impact on this node
+ Math3D.VectorCopy(mid, lightspot);
+ lightplane = plane;
+ int surfIndex = node.firstsurface;
+
+ msurface_t surf;
+ int s, t, ds, dt;
+ mtexinfo_t tex;
+ ByteBuffer lightmap;
+ int maps;
+ for (int 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[] rgb;
+ lightmapIndex += 3 * (dt * ((surf.extents[0] >> 4) + 1) + ds);
+
+ float scale0, scale1, scale2;
+ for (maps = 0; maps < Defines.MAXLIGHTMAPS
+ && surf.styles[maps] != (byte) 255; maps++) {
+ rgb = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb;
+ scale0 = gl_modulate.value * rgb[0];
+ scale1 = gl_modulate.value * rgb[1];
+ scale2 = gl_modulate.value * rgb[2];
+
+ pointcolor[0] += (lightmap.get(lightmapIndex + 0) & 0xFF)
+ * scale0 * (1.0f / 255);
+ pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF)
+ * scale1 * (1.0f / 255);
+ pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF)
+ * scale2 * (1.0f / 255);
+ lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1)
+ * ((surf.extents[1] >> 4) + 1);
+ }
+ }
+ Vec3Cache.release(); // mid
+ return 1;
+ }
+
+ // go down back side
+ r = RecursiveLightPoint(node.children[1 - sideIndex], mid, end);
+ Vec3Cache.release(); // mid
+ return r;
+ }
+
+ /**
+ * R_MarkLights
+ */
+ protected void R_MarkLights(dlight_t light, int bit, mnode_t node) {
+ if (node.contents != -1)
+ return;
+
+ cplane_t splitplane = node.plane;
+ float 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
+ msurface_t surf;
+ int sidebit;
+ for (int 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_SetCacheState
+ */
+ protected void R_SetCacheState(msurface_t surf) {
+ for (int maps = 0; maps < Defines.MAXLIGHTMAPS
+ && surf.styles[maps] != (byte) 255; maps++) {
+ surf.cached_light[maps] = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].white;
+ }
+ }
+
+
+ /**
+ * R_PushDlights
+ */
+ protected void R_PushDlights() {
+ if (gl_flashblend.value != 0)
+ return;
+
+ r_dlightframecount = r_framecount + 1; // because the count hasn't
+ // advanced yet for this frame
+ dlight_t l;
+ for (int i = 0; i < r_newrefdef.num_dlights; i++) {
+ l = r_newrefdef.dlights[i];
+ R_MarkLights(l, 1 << i, r_worldmodel.nodes[0]);
+ }
+ }
+
+
+ /*
+ * =============================================================================
+ *
+ * DYNAMIC LIGHTS BLEND RENDERING
+ *
+ * =============================================================================
+ */
+
+ void R_RenderDlight(dlight_t light) {
+ float rad = light.intensity * 0.35f;
+ float[] v = Vec3Cache.get();
+ Math3D.VectorSubtract(light.origin, r_origin, v);
+
+ ggl.glBegin(ggl.GL_TRIANGLE_FAN);
+ ggl.glColor3f(light.color[0] * 0.2f, light.color[1] * 0.2f,
+ light.color[2] * 0.2f);
+ for (int i = 0; i < 3; i++)
+ v[i] = light.origin[i] - vpn[i] * rad;
+
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ ggl.glColor3f(0, 0, 0);
+ float a;
+ for (int i = 16; i >= 0; i--) {
+ a = (float) (i / 16.0f * Math.PI * 2);
+ for (int j = 0; j < 3; j++)
+ v[j] = (float) (light.origin[j] + vright[j] * Math.cos(a) * rad + vup[j]
+ * Math.sin(a) * rad);
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ }
+ ggl.glEnd();
+ Vec3Cache.release();
+ }
+
+
+ /**
+ * ============= R_RenderDlights =============
+ */
+ public void R_RenderDlights() {
+ if (gl_flashblend.value == 0)
+ return;
+
+ r_dlightframecount = r_framecount + 1; // because the count hasn't
+ // advanced yet for this frame
+ ggl.glDepthMask(false);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glShadeModel(ggl.GL_SMOOTH);
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glBlendFunc(ggl.GL_ONE, ggl.GL_ONE);
+
+ for (int i = 0; i < r_newrefdef.num_dlights; i++) {
+ R_RenderDlight(r_newrefdef.dlights[i]);
+ }
+
+ ggl.glColor3f(1, 1, 1);
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glBlendFunc(ggl.GL_SRC_ALPHA, ggl.GL_ONE_MINUS_SRC_ALPHA);
+ ggl.glDepthMask(true);
+ }
+}
diff --git a/src/jake2/render/common/Main.java b/src/jake2/render/common/Main.java
new file mode 100644
index 0000000..a4deeb7
--- /dev/null
+++ b/src/jake2/render/common/Main.java
@@ -0,0 +1,1181 @@
+/*
+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 19.08.2006 by RST.
+
+// $Id: Main.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+import jake2.Defines;
+import jake2.Globals;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.util.Math3D;
+import jake2.util.Vargs;
+
+import java.awt.Dimension;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+public abstract class Main extends Base {
+
+ // =================
+ // abstract methods
+ // =================
+ protected abstract void Draw_GetPalette();
+ protected abstract void Draw_InitLocal();
+
+ protected abstract boolean GL_Upload32(int[] data, int width, int height, boolean mipmap);
+ protected abstract boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, boolean is_sky);
+ protected abstract void GL_Bind(int texnum);
+ protected abstract void GL_SelectTexture(int target);
+ protected abstract void GL_ImageList_f();
+ protected abstract void GL_InitImages();
+ protected abstract void GL_TextureAlphaMode(String name);
+ protected abstract void GL_TextureSolidMode(String name);
+ protected abstract void GL_ScreenShot_f();
+ protected abstract void GL_SetTexturePalette(int[] palette);
+ protected abstract void GL_Strings_f();
+ protected abstract void GL_SetDefaultState();
+ protected abstract void GL_ShutdownImages();
+ protected abstract void GL_TexEnv(int mode);
+ protected abstract void GL_TextureMode(String string);
+ protected abstract void GL_UpdateSwapInterval();
+ protected abstract image_t GL_FindImage(String name, int type);
+ protected abstract void GL_FreeUnusedImages();
+ protected abstract void GL_EndBuildingLightmaps();
+ protected abstract void GL_BeginBuildingLightmaps(model_t model);
+ protected abstract void GL_BuildPolygonFromSurface(msurface_t surface);
+ protected abstract void GL_CreateSurfaceLightmap(msurface_t survace);
+ protected abstract void GL_SubdivideSurface(msurface_t survace);
+
+
+ protected abstract void R_InitParticleTexture(); // MIsc.java
+ protected abstract void R_DrawAliasModel(entity_t e); // Mesh.java
+ protected abstract void R_DrawBrushModel(entity_t e); // Surf.java
+ protected abstract void R_LightPoint(float[] p, float[] color);
+ protected abstract void R_PushDlights();
+ protected abstract void R_MarkLeaves();
+ protected abstract void R_DrawWorld();
+ protected abstract void R_RenderDlights();
+ protected abstract void R_DrawAlphaSurfaces();
+ protected abstract void R_SetupFrame();
+
+ protected abstract void Mod_Modellist_f();
+ protected abstract void Mod_FreeAll();
+ protected abstract void GLimp_Finish();
+ protected abstract void GLimp_Shutdown();
+ protected abstract int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen);
+
+ protected static int[] d_8to24table = new int[256];
+
+ protected int c_visible_lightmaps;
+
+ protected int c_visible_textures;
+
+ protected int registration_sequence;
+
+ // this a hack for function pointer test
+ // default disabled
+ protected boolean qglColorTableEXT = true;
+
+ protected boolean qglActiveTextureARB = false;
+
+ protected boolean qglPointParameterfEXT = false;
+
+ protected boolean qglLockArraysEXT = false;
+
+ protected boolean qwglSwapIntervalEXT = false;
+
+ protected static final int NUM_BEAM_SEGS = 6;
+
+ protected float[][] start_points = new float[NUM_BEAM_SEGS][3];
+
+ // array of vec3_t
+ protected float[][] end_points = new float[NUM_BEAM_SEGS][3]; // array of vec3_t
+
+ /*
+ * ====================================================================
+ *
+ * from gl_rmain.c
+ *
+ * ====================================================================
+ */
+
+ protected model_t r_worldmodel;
+
+ protected float gldepthmin, gldepthmax;
+
+ protected glconfig_t gl_config = new glconfig_t();
+
+ protected glstate_t gl_state = new glstate_t();
+
+ protected image_t r_notexture; // use for bad textures
+
+ protected image_t r_particletexture; // little dot for particles
+
+ protected entity_t currententity;
+
+ protected model_t currentmodel;
+
+ protected cplane_t frustum[] = { new cplane_t(), new cplane_t(), new cplane_t(),
+ new cplane_t() };
+
+ protected int r_visframecount; // bumped when going to a new PVS
+
+ protected int r_framecount; // used for dlight push checking
+
+ protected int c_brush_polys, c_alias_polys;
+
+ protected float v_blend[] = { 0, 0, 0, 0 }; // final blending color
+
+ //
+ // view origin
+ //
+ protected float[] vup = { 0, 0, 0 };
+
+ protected float[] vpn = { 0, 0, 0 };
+
+ protected float[] vright = { 0, 0, 0 };
+
+ protected float[] r_origin = { 0, 0, 0 };
+
+ protected float r_world_matrix[] = new float[16];
+
+ protected float r_base_world_matrix[] = new float[16];
+
+ //
+ // screen size info
+ //
+ protected refdef_t r_newrefdef = new refdef_t();
+
+ protected int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2;
+
+ protected cvar_t r_norefresh;
+
+ protected cvar_t r_drawentities;
+
+ protected cvar_t r_drawworld;
+
+ protected cvar_t r_speeds;
+
+ protected cvar_t r_fullbright;
+
+ protected cvar_t r_novis;
+
+ protected cvar_t r_nocull;
+
+ protected cvar_t r_lerpmodels;
+
+ protected cvar_t r_lefthand;
+
+ protected cvar_t r_lightlevel;
+
+ protected cvar_t gl_nosubimage;
+
+ protected cvar_t gl_allow_software;
+
+ protected cvar_t gl_vertex_arrays;
+
+ protected cvar_t gl_particle_min_size;
+
+ protected cvar_t gl_particle_max_size;
+
+ protected cvar_t gl_particle_size;
+
+ protected cvar_t gl_particle_att_a;
+
+ protected cvar_t gl_particle_att_b;
+
+ protected cvar_t gl_particle_att_c;
+
+ protected cvar_t gl_ext_swapinterval;
+
+ protected cvar_t gl_ext_palettedtexture;
+
+ protected cvar_t gl_ext_multitexture;
+
+ protected cvar_t gl_ext_pointparameters;
+
+ protected cvar_t gl_ext_compiled_vertex_array;
+
+ protected cvar_t gl_log;
+
+ protected cvar_t gl_bitdepth;
+
+ protected cvar_t gl_drawbuffer;
+
+ protected cvar_t gl_driver;
+
+ protected cvar_t gl_lightmap;
+
+ protected cvar_t gl_shadows;
+
+ protected cvar_t gl_mode;
+
+ protected cvar_t gl_dynamic;
+
+ protected cvar_t gl_monolightmap;
+
+ protected cvar_t gl_modulate;
+
+ protected cvar_t gl_nobind;
+
+ protected cvar_t gl_round_down;
+
+ protected cvar_t gl_picmip;
+
+ protected cvar_t gl_skymip;
+
+ protected cvar_t gl_showtris;
+
+ protected cvar_t gl_ztrick;
+
+ protected cvar_t gl_finish;
+
+ protected cvar_t gl_clear;
+
+ protected cvar_t gl_cull;
+
+ protected cvar_t gl_polyblend;
+
+ protected cvar_t gl_flashblend;
+
+ protected cvar_t gl_playermip;
+
+ protected cvar_t gl_saturatelighting;
+
+ protected cvar_t gl_swapinterval;
+
+ protected cvar_t gl_texturemode;
+
+ protected cvar_t gl_texturealphamode;
+
+ protected cvar_t gl_texturesolidmode;
+
+ protected cvar_t gl_lockpvs;
+
+ protected cvar_t gl_3dlabs_broken;
+
+ protected cvar_t vid_gamma;
+
+ protected cvar_t vid_ref;
+
+ protected int[] r_rawpalette = new int[256];
+
+ protected float[] r_turbsin = new float[256];
+
+ protected int trickframe = 0;
+
+ protected cvar_t vid_fullscreen;
+
+ // window position on the screen
+ protected int window_xpos, window_ypos;
+ protected viddef_t vid = new viddef_t();
+
+ // enum rserr_t
+ protected static final int rserr_ok = 0;
+ protected static final int rserr_invalid_fullscreen = 1;
+ protected static final int rserr_invalid_mode = 2;
+ protected static final int rserr_unknown = 3;
+
+
+ /**
+ * R_Register
+ */
+ protected void R_Register() {
+ r_lefthand = Cvar.Get("hand", "0", Globals.CVAR_USERINFO | Globals.CVAR_ARCHIVE);
+ r_norefresh = Cvar.Get("r_norefresh", "0", 0);
+ r_fullbright = Cvar.Get("r_fullbright", "0", 0);
+ r_drawentities = Cvar.Get("r_drawentities", "1", 0);
+ r_drawworld = Cvar.Get("r_drawworld", "1", 0);
+ r_novis = Cvar.Get("r_novis", "0", 0);
+ r_nocull = Cvar.Get("r_nocull", "0", 0);
+ r_lerpmodels = Cvar.Get("r_lerpmodels", "1", 0);
+ r_speeds = Cvar.Get("r_speeds", "0", 0);
+
+ r_lightlevel = Cvar.Get("r_lightlevel", "1", 0);
+
+ gl_nosubimage = Cvar.Get("gl_nosubimage", "0", 0);
+ gl_allow_software = Cvar.Get("gl_allow_software", "0", 0);
+
+ gl_particle_min_size = Cvar.Get("gl_particle_min_size", "2", Globals.CVAR_ARCHIVE);
+ gl_particle_max_size = Cvar.Get("gl_particle_max_size", "40", Globals.CVAR_ARCHIVE);
+ gl_particle_size = Cvar.Get("gl_particle_size", "40", Globals.CVAR_ARCHIVE);
+ gl_particle_att_a = Cvar.Get("gl_particle_att_a", "0.01", Globals.CVAR_ARCHIVE);
+ gl_particle_att_b = Cvar.Get("gl_particle_att_b", "0.0", Globals.CVAR_ARCHIVE);
+ gl_particle_att_c = Cvar.Get("gl_particle_att_c", "0.01", Globals.CVAR_ARCHIVE);
+
+ gl_modulate = Cvar.Get("gl_modulate", "1.5", Globals.CVAR_ARCHIVE);
+ gl_log = Cvar.Get("gl_log", "0", 0);
+ gl_bitdepth = Cvar.Get("gl_bitdepth", "0", 0);
+ gl_mode = Cvar.Get("gl_mode", "3", Globals.CVAR_ARCHIVE); // 640x480
+ gl_lightmap = Cvar.Get("gl_lightmap", "0", 0);
+ gl_shadows = Cvar.Get("gl_shadows", "0", Globals.CVAR_ARCHIVE);
+ gl_dynamic = Cvar.Get("gl_dynamic", "1", 0);
+ gl_nobind = Cvar.Get("gl_nobind", "0", 0);
+ gl_round_down = Cvar.Get("gl_round_down", "1", 0);
+ gl_picmip = Cvar.Get("gl_picmip", "0", 0);
+ gl_skymip = Cvar.Get("gl_skymip", "0", 0);
+ gl_showtris = Cvar.Get("gl_showtris", "0", 0);
+ gl_ztrick = Cvar.Get("gl_ztrick", "0", 0);
+ gl_finish = Cvar.Get("gl_finish", "0", Globals.CVAR_ARCHIVE);
+ gl_clear = Cvar.Get("gl_clear", "0", 0);
+ gl_cull = Cvar.Get("gl_cull", "1", 0);
+ gl_polyblend = Cvar.Get("gl_polyblend", "1", 0);
+ gl_flashblend = Cvar.Get("gl_flashblend", "0", 0);
+ gl_playermip = Cvar.Get("gl_playermip", "0", 0);
+ gl_monolightmap = Cvar.Get("gl_monolightmap", "0", 0);
+ gl_driver = Cvar.Get("gl_driver", "opengl32", Globals.CVAR_ARCHIVE);
+ gl_texturemode = Cvar.Get("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", Globals.CVAR_ARCHIVE);
+ gl_texturealphamode = Cvar.Get("gl_texturealphamode", "default", Globals.CVAR_ARCHIVE);
+ gl_texturesolidmode = Cvar.Get("gl_texturesolidmode", "default", Globals.CVAR_ARCHIVE);
+ gl_lockpvs = Cvar.Get("gl_lockpvs", "0", 0);
+
+ gl_vertex_arrays = Cvar.Get("gl_vertex_arrays", "1", Globals.CVAR_ARCHIVE);
+
+ gl_ext_swapinterval = Cvar.Get("gl_ext_swapinterval", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_palettedtexture = Cvar.Get("gl_ext_palettedtexture", "0", Globals.CVAR_ARCHIVE);
+ gl_ext_multitexture = Cvar.Get("gl_ext_multitexture", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_pointparameters = Cvar.Get("gl_ext_pointparameters", "1", Globals.CVAR_ARCHIVE);
+ gl_ext_compiled_vertex_array = Cvar.Get("gl_ext_compiled_vertex_array", "1", Globals.CVAR_ARCHIVE);
+
+ gl_drawbuffer = Cvar.Get("gl_drawbuffer", "GL_BACK", 0);
+ gl_swapinterval = Cvar.Get("gl_swapinterval", "0", Globals.CVAR_ARCHIVE);
+
+ gl_saturatelighting = Cvar.Get("gl_saturatelighting", "0", 0);
+
+ gl_3dlabs_broken = Cvar.Get("gl_3dlabs_broken", "1", Globals.CVAR_ARCHIVE);
+
+ vid_fullscreen = Cvar.Get("vid_fullscreen", "0", Globals.CVAR_ARCHIVE);
+ vid_gamma = Cvar.Get("vid_gamma", "1.0", Globals.CVAR_ARCHIVE);
+ vid_ref = Cvar.Get("vid_ref", "lwjgl", Globals.CVAR_ARCHIVE);
+
+ Cmd.AddCommand("imagelist", new xcommand_t() {
+ public void execute() {
+ GL_ImageList_f();
+ }
+ });
+
+ Cmd.AddCommand("screenshot", new xcommand_t() {
+ public void execute() {
+ GL_ScreenShot_f();
+ }
+ });
+ Cmd.AddCommand("modellist", new xcommand_t() {
+ public void execute() {
+ Mod_Modellist_f();
+ }
+ });
+ Cmd.AddCommand("gl_strings", new xcommand_t() {
+ public void execute() {
+ GL_Strings_f();
+ }
+ });
+ }
+
+
+ /**
+ * R_CullBox Returns true if the box is completely outside the frustum
+ */
+ protected 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;
+ }
+
+ protected 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;
+ }
+
+ protected 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]);
+ }
+ }
+
+ protected abstract void GL_GetWorldMatrix();
+
+ /**
+ * R_SetupGL
+ */
+ protected void R_SetupGL() {
+
+ //
+ // set up viewport
+ //
+ int x = r_newrefdef.x;
+ int x2 = r_newrefdef.x + r_newrefdef.width;
+ int y = vid.height - r_newrefdef.y;
+ int y2 = vid.height - (r_newrefdef.y + r_newrefdef.height);
+
+ int w = x2 - x;
+ int h = y - y2;
+
+ ggl.glViewport(x, y2, w, h);
+
+ //
+ // set up projection matrix
+ //
+ float screenaspect = (float) r_newrefdef.width / r_newrefdef.height;
+ ggl.glMatrixMode(ggl.GL_PROJECTION);
+ ggl.glLoadIdentity();
+ MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096);
+
+ ggl.glCullFace(ggl.GL_FRONT);
+
+ ggl.glMatrixMode(ggl.GL_MODELVIEW);
+ ggl.glLoadIdentity();
+
+ ggl.glRotatef(-90, 1, 0, 0); // put Z going up
+ ggl.glRotatef(90, 0, 0, 1); // put Z going up
+ ggl.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0);
+ ggl.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0);
+ ggl.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1);
+ ggl.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]);
+
+ GL_GetWorldMatrix();
+
+ //
+ // set drawing parms
+ //
+ if (gl_cull.value != 0.0f)
+ ggl.glEnable(ggl.GL_CULL_FACE);
+ else
+ ggl.glDisable(ggl.GL_CULL_FACE);
+
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+ ggl.glEnable(ggl.GL_DEPTH_TEST);
+ }
+
+ /**
+ * R_Clear.
+ */
+
+ protected void R_Clear() {
+ if (gl_ztrick.value != 0.0f) {
+
+ if (gl_clear.value != 0.0f) {
+ ggl.glClear(ggl.GL_COLOR_BUFFER_BIT);
+ }
+
+ trickframe++;
+ if ((trickframe & 1) != 0) {
+ gldepthmin = 0;
+ gldepthmax = 0.49999f;
+ ggl.glDepthFunc(ggl.GL_LEQUAL);
+ }
+ else {
+ gldepthmin = 1;
+ gldepthmax = 0.5f;
+ ggl.glDepthFunc(ggl.GL_GEQUAL);
+ }
+ }
+ else {
+ if (gl_clear.value != 0.0f)
+ ggl.glClear(ggl.GL_COLOR_BUFFER_BIT | ggl.GL_DEPTH_BUFFER_BIT);
+ else
+ ggl.glClear(ggl.GL_DEPTH_BUFFER_BIT);
+
+ gldepthmin = 0;
+ gldepthmax = 1;
+ ggl.glDepthFunc(ggl.GL_LEQUAL);
+ }
+ ggl.glDepthRange(gldepthmin, gldepthmax);
+ }
+
+ protected void R_SetGL2D() {
+ // set 2D virtual screen size
+ ggl.glViewport(0, 0, vid.width, vid.height);
+ ggl.glMatrixMode(ggl.GL_PROJECTION);
+ ggl.glLoadIdentity();
+ ggl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999);
+ ggl.glMatrixMode(ggl.GL_MODELVIEW);
+ ggl.glLoadIdentity();
+ ggl.glDisable(ggl.GL_DEPTH_TEST);
+ ggl.glDisable(ggl.GL_CULL_FACE);
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glEnable(ggl.GL_ALPHA_TEST);
+ ggl.glColor4f(1, 1, 1, 1);
+ }
+
+
+
+ /**
+ * R_RenderView.
+ *
+ * r_newrefdef must be set before the first call
+ */
+ protected void R_RenderView(refdef_t fd) {
+
+ if (r_norefresh.value != 0.0f)
+ return;
+
+ r_newrefdef = fd;
+
+ // included by cwei
+ if (r_newrefdef == null) {
+ Com.Error(Defines.ERR_DROP, "R_RenderView: refdef_t fd is null");
+ }
+
+ if (r_worldmodel == null
+ && (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0)
+ Com.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)
+ GLimp_Finish();
+
+ 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) {
+ VID.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));
+ }
+ }
+
+ /**
+ * R_RenderFrame.
+ *
+ */
+ protected void R_RenderFrame(refdef_t fd) {
+ R_RenderView(fd);
+ R_SetLightLevel();
+ R_SetGL2D();
+ }
+
+
+ /**
+ * R_Shutdown
+ */
+ protected void R_Shutdown() {
+ Cmd.RemoveCommand("modellist");
+ Cmd.RemoveCommand("screenshot");
+ Cmd.RemoveCommand("imagelist");
+ Cmd.RemoveCommand("gl_strings");
+
+ Mod_FreeAll();
+
+ GL_ShutdownImages();
+
+ /*
+ * shut down OS specific OpenGL stuff like contexts, etc.
+ */
+ GLimp_Shutdown();
+ }
+
+ // stack variable
+ private final float[] light = { 0, 0, 0 };
+
+ /**
+ * R_SetLightLevel
+ */
+ void R_SetLightLevel() {
+ 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, light);
+
+ // pick the greatest component, which should be the same
+ // as the mono value returned by software
+ if (light[0] > light[1]) {
+ if (light[0] > light[2])
+ r_lightlevel.value = 150 * light[0];
+ else
+ r_lightlevel.value = 150 * light[2];
+ } else {
+ if (light[1] > light[2])
+ r_lightlevel.value = 150 * light[1];
+ else
+ r_lightlevel.value = 150 * light[2];
+ }
+ }
+
+ /**
+ * R_Flash
+ */
+ protected void R_Flash() {
+ R_PolyBlend();
+ }
+
+
+ protected 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;
+
+ ggl.glFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
+ }
+
+
+ /**
+ * R_SetMode
+ */
+ protected boolean R_SetMode() {
+ boolean fullscreen = (vid_fullscreen.value > 0.0f);
+
+ vid_fullscreen.modified = false;
+ gl_mode.modified = false;
+
+ Dimension dim = new Dimension(vid.width, vid.height);
+
+ int err; // enum rserr_t
+ 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) {
+ Cvar.SetValue("vid_fullscreen", 0);
+ vid_fullscreen.modified = false;
+ VID.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) {
+ Cvar.SetValue("gl_mode", gl_state.prev_mode);
+ gl_mode.modified = false;
+ VID.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) {
+ VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - could not revert to safe mode\n");
+ return false;
+ }
+ }
+ return true;
+ }
+
+
+ /*
+ =============================================================
+
+ 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)
+ ggl.glEnable(ggl.GL_BLEND);
+
+ ggl.glColor4f(1, 1, 1, alpha);
+
+ GL_Bind(currentmodel.skins[e.frame].texnum);
+
+ GL_TexEnv(ggl.GL_MODULATE);
+
+ if (alpha == 1.0)
+ ggl.glEnable(ggl.GL_ALPHA_TEST);
+ else
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+
+ ggl.glBegin(ggl.GL_QUADS);
+
+ ggl.glTexCoord2f(0, 1);
+ Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
+ Math3D.VectorMA(point, -frame.origin_x, vright, point);
+ ggl.glVertex3f(point[0], point[1], point[2]);
+
+ ggl.glTexCoord2f(0, 0);
+ Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
+ Math3D.VectorMA(point, -frame.origin_x, vright, point);
+ ggl.glVertex3f(point[0], point[1], point[2]);
+
+ ggl.glTexCoord2f(1, 0);
+ Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
+ Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
+ ggl.glVertex3f(point[0], point[1], point[2]);
+
+ ggl.glTexCoord2f(1, 1);
+ Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
+ Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
+ ggl.glVertex3f(point[0], point[1], point[2]);
+
+ ggl.glEnd();
+
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+ GL_TexEnv(ggl.GL_REPLACE);
+
+ if (alpha != 1.0F)
+ ggl.glDisable(ggl.GL_BLEND);
+
+ ggl.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);
+ }
+
+ ggl.glPushMatrix();
+ R_RotateForEntity(currententity);
+
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glColor3f(shadelight[0], shadelight[1], shadelight[2]);
+
+ // this replaces the TRIANGLE_FAN
+ //GlutWireCube();
+ ggl.glBegin(ggl.GL_TRIANGLE_FAN);
+ ggl.glVertex3f(0, 0, -16);
+ int i;
+ for (i = 0; i <= 4; i++) {
+ ggl.glVertex3f((float) (16.0f * Math.cos(i * Math.PI / 2)),
+ (float) (16.0f * Math.sin(i * Math.PI / 2)), 0.0f);
+ }
+ ggl.glEnd();
+
+ ggl.glBegin(ggl.GL_TRIANGLE_FAN);
+ ggl.glVertex3f(0, 0, 16);
+ for (i = 4; i >= 0; i--) {
+ ggl.glVertex3f((float) (16.0f * Math.cos(i * Math.PI / 2)),
+ (float) (16.0f * Math.sin(i * Math.PI / 2)), 0.0f);
+ }
+ ggl.glEnd();
+
+ ggl.glColor3f(1, 1, 1);
+ ggl.glPopMatrix();
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ }
+
+ protected abstract void R_RotateForEntity(entity_t currententity);
+
+
+ /**
+ * R_DrawEntitiesOnList
+ */
+ protected 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 Base.mod_alias:
+ R_DrawAliasModel(currententity);
+ break;
+ case Base.mod_brush:
+ R_DrawBrushModel(currententity);
+ break;
+ case Base.mod_sprite:
+ R_DrawSpriteModel(currententity);
+ break;
+ default:
+ Com.Error(Defines.ERR_DROP, "Bad modeltype:" + currentmodel.type);
+ break;
+ }
+ }
+ }
+ // draw transparent entities
+ // we could sort these if it ever becomes a problem...
+ ggl.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 Base.mod_alias:
+ R_DrawAliasModel(currententity);
+ break;
+ case Base.mod_brush:
+ R_DrawBrushModel(currententity);
+ break;
+ case Base.mod_sprite:
+ R_DrawSpriteModel(currententity);
+ break;
+ default :
+ //Com.Error(Defines.ERR_DROP, "Bad modeltype");
+ //this can happen sometimes because of a threading issue with jogl/lwjgl?
+ //the fatal error was changed to a graceful return.
+ ggl.glDepthMask(true);
+ return;
+ //break;
+ }
+ }
+ }
+ ggl.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);
+ ggl.glDepthMask(false); // no z buffering
+ ggl.glEnable(ggl.GL_BLEND);
+ GL_TexEnv(ggl.GL_MODULATE);
+
+ ggl.glBegin(ggl.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);
+
+ ggl.glColor4ub((byte) ((color) & 0xFF),
+ (byte) ((color >> 8) & 0xFF),
+ (byte) ((color >> 16) & 0xFF),
+ (byte) ((color >>> 24)));
+
+ // first vertex
+ ggl.glTexCoord2f(0.0625f, 0.0625f);
+ ggl.glVertex3f(origin_x, origin_y, origin_z);
+ // second vertex
+ ggl.glTexCoord2f(1.0625f, 0.0625f);
+ ggl.glVertex3f(origin_x + up[0] * scale, origin_y + up[1] * scale, origin_z + up[2] * scale);
+ // third vertex
+ ggl.glTexCoord2f(0.0625f, 1.0625f);
+ ggl.glVertex3f(origin_x + right[0] * scale, origin_y + right[1] * scale, origin_z + right[2] * scale);
+ }
+ ggl.glEnd();
+
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glColor4f(1, 1, 1, 1);
+ ggl.glDepthMask(true); // back to normal Z buffering
+ GL_TexEnv(ggl.GL_REPLACE);
+ }
+
+ /**
+ * R_DrawParticles
+ */
+ protected void R_DrawParticles() {
+
+ if (gl_ext_pointparameters.value != 0.0f && qglPointParameterfEXT) {
+
+ //ggl.glEnableClientState(ggl.GL_VERTEX_ARRAY);
+ ggl.glVertexPointer(3, ggl.GL_FLOAT, 0, particle_t.vertexArray);
+ ggl.glEnableClientState(ggl.GL_COLOR_ARRAY);
+ ggl.glColorPointer(4, ggl.GL_UNSIGNED_BYTE, 0, particle_t.getColorAsByteBuffer());
+
+ ggl.glDepthMask(false);
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glPointSize(gl_particle_size.value);
+
+ ggl.glDrawArrays(ggl.GL_POINTS, 0, r_newrefdef.num_particles);
+
+ ggl.glDisableClientState(ggl.GL_COLOR_ARRAY);
+ //ggl.glDisableClientState(ggl.GL_VERTEX_ARRAY);
+
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+ ggl.glDepthMask(true);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+
+ }
+ else {
+ GL_DrawParticles(r_newrefdef.num_particles);
+ }
+ }
+
+ /*
+ ============
+ R_PolyBlend
+ ============
+ */
+ protected void R_PolyBlend() {
+ if (gl_polyblend.value == 0.0f)
+ return;
+
+ if (v_blend[3] == 0.0f)
+ return;
+
+ ggl.glDisable(ggl.GL_ALPHA_TEST);
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.glDisable(ggl.GL_DEPTH_TEST);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+
+ ggl.glLoadIdentity();
+
+ // FIXME: get rid of these
+ ggl.glRotatef(-90, 1, 0, 0); // put Z going up
+ ggl.glRotatef(90, 0, 0, 1); // put Z going up
+
+ ggl.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]);
+
+ ggl.glBegin(ggl.GL_QUADS);
+
+ ggl.glVertex3f(10, 100, 100);
+ ggl.glVertex3f(10, -100, 100);
+ ggl.glVertex3f(10, -100, -100);
+ ggl.glVertex3f(10, 100, -100);
+ ggl.glEnd();
+
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ ggl.glEnable(ggl.GL_ALPHA_TEST);
+
+ ggl.glColor4f(1, 1, 1, 1);
+ }
+
+
+ /**
+ * 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);
+
+ ggl.glClearColor(0, 0, 0, 0);
+ ggl.glClear(ggl.GL_COLOR_BUFFER_BIT);
+ ggl.glClearColor(1f, 0f, 0.5f, 0.5f);
+ }
+
+
+ /**
+ * R_DrawBeam
+ */
+ protected 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]);
+ }
+
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.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;
+
+ ggl.glColor4f(r, g, b, e.alpha);
+
+ ggl.glBegin(ggl.GL_TRIANGLE_STRIP);
+
+ float[] v;
+
+ for (i = 0; i < jake2.render.common.Main.NUM_BEAM_SEGS; i++) {
+ v = start_points[i];
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ v = end_points[i];
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ v = start_points[(i + 1) % jake2.render.common.Main.NUM_BEAM_SEGS];
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ v = end_points[(i + 1) % jake2.render.common.Main.NUM_BEAM_SEGS];
+ ggl.glVertex3f(v[0], v[1], v[2]);
+ }
+ ggl.glEnd();
+
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glDepthMask(true);
+ }
+}
diff --git a/src/jake2/render/common/Mesh.java b/src/jake2/render/common/Mesh.java
new file mode 100644
index 0000000..182dfc8
--- /dev/null
+++ b/src/jake2/render/common/Mesh.java
@@ -0,0 +1,707 @@
+/*
+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.08.2006 by RST.
+// $Id: Mesh.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import jake2.Defines;
+import jake2.client.VID;
+import jake2.client.entity_t;
+import jake2.qcommon.qfiles;
+import jake2.render.image_t;
+import jake2.util.Math3D;
+import jake2.util.Vec3Cache;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import net.java.games.joal.util.BufferUtils;
+
+
+public abstract class Mesh extends Light {
+
+
+ protected static final int NUMVERTEXNORMALS = 162;
+
+ protected float[][] r_avertexnormals = Anorms.VERTEXNORMALS;
+
+ protected float[] shadevector = { 0, 0, 0 };
+
+ protected float[] shadelight = { 0, 0, 0 };
+
+ // precalculated dot products for quantized angles
+ protected static final int SHADEDOT_QUANT = 16;
+
+ protected float[][] r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS;
+
+ protected float[] shadedots = r_avertexnormal_dots[0];
+
+ // bounding box
+ protected 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_InitParticleTexture ==================
+ */
+ protected 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 }, };
+
+ protected 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, Base.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, Base.it_wall, 32);
+ }
+
+ /**
+ * GL_LerpVerts
+ */
+ protected void GL_LerpVerts(int nverts, int[] ov, int[] v, float[] move,
+ float[] frontv, float[] backv) {
+ FloatBuffer lerp = vertexArrayBuf;
+ lerp.limit((nverts << 2) - nverts); // nverts * 3
+
+ int ovv, 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 (int i = 0; i < nverts; i++/* , v++, ov++, lerp+=4 */) {
+ vv = v[i];
+ normal = r_avertexnormals[(vv >>> 24) & 0xFF];
+ ovv = ov[i];
+ lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0] + normal[0] * Defines.POWERSUIT_SCALE);
+ lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1] + normal[1] * Defines.POWERSUIT_SCALE);
+ lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2] + normal[2] * Defines.POWERSUIT_SCALE);
+ j += 3;
+ }
+ } else {
+ int j = 0;
+ for (int i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */) {
+ ovv = ov[i];
+ vv = v[i];
+
+ lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0]);
+ lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1]);
+ lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2]);
+ j += 3;
+ }
+ }
+ }
+
+ protected FloatBuffer colorArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 4);
+ protected FloatBuffer vertexArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 3);
+ protected FloatBuffer textureArrayBuf = BufferUtils.newFloatBuffer(qfiles.MAX_VERTS * 2);
+
+ protected boolean isFilled = false;
+
+ protected float[] tmpVec = { 0, 0, 0 };
+
+ protected float[][] vectors = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } // 3 mal vec3_t
+ };
+
+ /**
+ * R_CullAliasModel
+ */
+ // TODO sync with jogl renderer. hoz
+ protected boolean R_CullAliasModel(entity_t e) {
+ qfiles.dmdl_t paliashdr = (qfiles.dmdl_t) currentmodel.extradata;
+
+ if ((e.frame >= paliashdr.num_frames) || (e.frame < 0)) {
+ VID.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)) {
+ VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such oldframe " + e.oldframe + '\n');
+ e.oldframe = 0;
+ }
+
+ qfiles.daliasframe_t pframe = paliashdr.aliasFrames[e.frame];
+ qfiles.daliasframe_t poldframe = paliashdr.aliasFrames[e.oldframe];
+
+ /*
+ * * compute axially aligned mins and maxs
+ */
+ float[] mins = Vec3Cache.get();
+ float[] maxs = Vec3Cache.get();
+
+ if (pframe == poldframe) {
+ for (int i = 0; i < 3; i++) {
+ mins[i] = pframe.translate[i];
+ maxs[i] = mins[i] + pframe.scale[i] * 255;
+ }
+ } else {
+ float thismaxs, oldmaxs;
+ for (int i = 0; i < 3; i++) {
+ thismaxs = pframe.translate[i] + pframe.scale[i] * 255;
+
+ oldmaxs = poldframe.translate[i] + poldframe.scale[i] * 255;
+
+ if (pframe.translate[i] < poldframe.translate[i])
+ mins[i] = pframe.translate[i];
+ else
+ mins[i] = poldframe.translate[i];
+
+ if (thismaxs > oldmaxs)
+ maxs[i] = thismaxs;
+ else
+ maxs[i] = oldmaxs;
+ }
+ }
+
+ /*
+ * * compute a full bounding box
+ */
+ float[] tmp;
+ for (int i = 0; i < 8; i++) {
+ tmp = bbox[i];
+ 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];
+ }
+
+ /*
+ * * rotate the bounding box
+ */
+ tmp = mins;
+ Math3D.VectorCopy(e.angles, tmp);
+ tmp[Base.YAW] = -tmp[Base.YAW];
+ Math3D.AngleVectors(tmp, vectors[0], vectors[1], vectors[2]);
+
+ for (int 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]);
+ }
+
+ Vec3Cache.release(2); // mins, maxs
+
+ int f, mask;
+ int aggregatemask = ~0; // 0xFFFFFFFF
+
+ for (int p = 0; p < 8; p++) {
+ 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;
+ }
+
+ /*
+ * =============================================================
+ *
+ * ALIAS MODELS
+ *
+ * =============================================================
+ */
+
+ protected void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp) {
+ int count;
+ float alpha;
+
+
+ qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame];
+
+ int[] verts = frame.verts;
+
+ qfiles.daliasframe_t oldframe = paliashdr.aliasFrames[currententity.oldframe];
+
+ int[] 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)
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+
+ float frontlerp = 1.0f - backlerp;
+
+ float[] frontv = Vec3Cache.get(); // vec3_t
+ // move should be the delta back to the previous frame * backlerp
+ Math3D.VectorSubtract(currententity.oldorigin, currententity.origin,
+ frontv);
+ Math3D.AngleVectors(currententity.angles, vectors[0], vectors[1],
+ vectors[2]);
+
+ float[] move = Vec3Cache.get(); // vec3_t
+ move[0] = Math3D.DotProduct(frontv, vectors[0]); // forward
+ move[1] = -Math3D.DotProduct(frontv, vectors[1]); // left
+ move[2] = Math3D.DotProduct(frontv, vectors[2]); // up
+
+ Math3D.VectorAdd(move, oldframe.translate, move);
+
+ float[] backv = Vec3Cache.get(); // vec3_t
+ for (int i = 0; i < 3; i++) {
+ move[i] = backlerp * move[i] + frontlerp * frame.translate[i];
+ frontv[i] = frontlerp * frame.scale[i];
+ backv[i] = backlerp * oldframe.scale[i];
+ }
+
+ // ab hier wird optimiert
+
+ GL_LerpVerts(paliashdr.num_xyz, ov, verts, move, frontv, backv);
+
+ Vec3Cache.release(3); // frontv, move, backv
+
+ //ggl.glEnableClientState( ggl.GL_VERTEX_ARRAY );
+ ggl.glVertexPointer(3, ggl.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) {
+ ggl.glColor4f(shadelight[0], shadelight[1], shadelight[2], alpha);
+ } else {
+ ggl.glEnableClientState(ggl.GL_COLOR_ARRAY);
+ ggl.glColorPointer(4, ggl.GL_FLOAT, 0, colorArrayBuf);
+
+ //
+ // pre light everything
+ //
+ FloatBuffer color = colorArrayBuf;
+ int j = 0;
+ float l;
+ for (int i = 0; i < paliashdr.num_xyz; i++) {
+ l = shadedots[(verts[i] >>> 24 ) & 0xFF];
+ color.put(j, l * shadelight[0]);
+ color.put(j + 1, l * shadelight[1]);
+ color.put(j + 2, l * shadelight[2]);
+ color.put(j + 3, alpha);
+ j += 4;
+ }
+ }
+
+ ggl.glClientActiveTextureARB(GL_TEXTURE0);
+ ggl.glTexCoordPointer(2, ggl.GL_FLOAT, 0, textureArrayBuf);
+ //ggl.glEnableClientState( ggl.GL_TEXTURE_COORD_ARRAY);
+
+ int pos = 0;
+ int[] counts = paliashdr.counts;
+
+ IntBuffer srcIndexBuf = null;
+
+ FloatBuffer dstTextureCoords = textureArrayBuf;
+ FloatBuffer srcTextureCoords = paliashdr.textureCoordBuf;
+
+ 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];
+
+ int mode = ggl.GL_TRIANGLE_STRIP;
+ if (count < 0) {
+ mode = ggl.GL_TRIANGLE_FAN;
+ count = -count;
+ }
+ srcIndex = pos << 1;
+ for (int k = 0; k < count; k++) {
+ dstIndex = srcIndexBuf.get(k) << 1;
+ dstTextureCoords.put(dstIndex++, srcTextureCoords.get(srcIndex++));
+ dstTextureCoords.put(dstIndex, srcTextureCoords.get(srcIndex++));
+ }
+
+ ggl.glDrawElements(mode, count, ggl.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)
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+
+ ggl.glDisableClientState(ggl.GL_COLOR_ARRAY);
+ }
+
+ /**
+ * ============= GL_DrawAliasShadow =============
+ */
+ protected void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum) {
+ int[] order;
+ float height, lheight;
+ int count;
+
+ lheight = currententity.origin[2] - lightspot[2];
+
+ height = 0;
+
+ order = paliashdr.glCmds;
+
+ height = -lheight + 1.0f;
+
+ int orderIndex = 0;
+ int index = 0;
+
+ // TODO shadow drawing with vertex arrays
+
+ float[] point = Vec3Cache.get();
+ while (true) {
+ // get the vertex count and primitive type
+ count = order[orderIndex++];
+ if (count == 0)
+ break; // done
+ if (count < 0) {
+ count = -count;
+ ggl.glBegin(ggl.GL_TRIANGLE_FAN);
+ }
+ else
+ ggl.glBegin(ggl.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;
+ ggl.glVertex3f(point[0], point[1], point[2]);
+
+ orderIndex += 3;
+
+ } while (--count != 0);
+
+ ggl.glEnd();
+ }
+ Vec3Cache.release(); // point
+ }
+
+ /*
+ * ================= R_DrawAliasModel
+ *
+ * =================
+ */
+ // TODO sync with jogl renderer. hoz
+ protected void R_DrawAliasModel(entity_t e) {
+ int i;
+
+ image_t skin;
+
+ if ((e.flags & Defines.RF_WEAPONMODEL) == 0) {
+ if (R_CullAliasModel(e))
+ return;
+ }
+
+ if ((e.flags & Defines.RF_WEAPONMODEL) != 0) {
+ if (r_lefthand.value == 2.0f)
+ return;
+ }
+
+ qfiles.dmdl_t 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)];
+
+ float 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
+ ggl.glDepthRange(gldepthmin, gldepthmin + 0.3
+ * (gldepthmax - gldepthmin));
+
+ if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0
+ && (r_lefthand.value == 1.0f)) {
+ ggl.glMatrixMode(ggl.GL_PROJECTION);
+ ggl.glPushMatrix();
+ ggl.glLoadIdentity();
+ ggl.glScalef(-1, 1, 1);
+ MYgluPerspective(r_newrefdef.fov_y, (float) r_newrefdef.width
+ / r_newrefdef.height, 4, 4096);
+ ggl.glMatrixMode(ggl.GL_MODELVIEW);
+
+ ggl.glCullFace(ggl.GL_BACK);
+ }
+
+ ggl.glPushMatrix();
+ e.angles[Base.PITCH] = -e.angles[Base.PITCH]; // sigh.
+ R_RotateForEntity(e);
+ e.angles[Base.PITCH] = -e.angles[Base.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
+
+ ggl.glShadeModel(ggl.GL_SMOOTH);
+
+ GL_TexEnv(ggl.GL_MODULATE);
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) {
+ ggl.glEnable(ggl.GL_BLEND);
+ }
+
+ if ((currententity.frame >= paliashdr.num_frames)
+ || (currententity.frame < 0)) {
+ VID.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)) {
+ VID.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(ggl.GL_REPLACE);
+ ggl.glShadeModel(ggl.GL_FLAT);
+
+ ggl.glPopMatrix();
+
+ if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0
+ && (r_lefthand.value == 1.0F)) {
+ ggl.glMatrixMode(ggl.GL_PROJECTION);
+ ggl.glPopMatrix();
+ ggl.glMatrixMode(ggl.GL_MODELVIEW);
+ ggl.glCullFace(ggl.GL_FRONT);
+ }
+
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) {
+ ggl.glDisable(ggl.GL_BLEND);
+ }
+
+ if ((currententity.flags & Defines.RF_DEPTHHACK) != 0)
+ ggl.glDepthRange(gldepthmin, gldepthmax);
+
+ if (gl_shadows.value != 0.0f
+ && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0) {
+ ggl.glPushMatrix();
+ R_RotateForEntity(e);
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.glColor4f(0, 0, 0, 0.5f);
+ GL_DrawAliasShadow(paliashdr, currententity.frame);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glPopMatrix();
+ }
+ ggl.glColor4f(1, 1, 1, 1);
+ }
+}
+
diff --git a/src/jake2/render/common/Misc.java b/src/jake2/render/common/Misc.java
new file mode 100644
index 0000000..6464c6b
--- /dev/null
+++ b/src/jake2/render/common/Misc.java
@@ -0,0 +1,58 @@
+/*
+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.08.2006 by RST.
+// $Id: Misc.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+
+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 }
+ };
+
+ /**
+ * GL_Strings_f
+ */
+ protected void GL_Strings_f() {
+ VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n');
+ VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n');
+ VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n');
+ VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n');
+ }
+}
diff --git a/src/jake2/render/common/Model.java b/src/jake2/render/common/Model.java
new file mode 100644
index 0000000..8c585b0
--- /dev/null
+++ b/src/jake2/render/common/Model.java
@@ -0,0 +1,1252 @@
+/*
+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 19.08.2006 by RST.
+
+// $Id: Model.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import jake2.Defines;
+import jake2.client.VID;
+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 loading and caching.
+ */
+public abstract class Model extends Image {
+
+ protected model_t loadmodel;
+
+ protected int modfilelen;
+
+ protected byte[] mod_novis = new byte[Defines.MAX_MAP_LEAFS / 8];
+
+ protected static final int MAX_MOD_KNOWN = 512;
+
+ protected model_t[] mod_known = new model_t[MAX_MOD_KNOWN];
+
+ protected int mod_numknown;
+
+ // the inline * models from the current map are kept seperate
+ protected model_t[] mod_inline = new model_t[MAX_MOD_KNOWN];
+
+ /**
+ * Mod_PointInLeaf
+ */
+ protected mleaf_t Mod_PointInLeaf(float[] p, model_t model) {
+ mnode_t node;
+ float d;
+ cplane_t plane;
+
+ if (model == null || model.nodes == null)
+ Com.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
+ }
+
+ protected byte[] decompressed = new byte[Defines.MAX_MAP_LEAFS / 8];
+
+ protected byte[] model_visibility = new byte[Defines.MAX_MAP_VISIBILITY];
+
+ /*
+ ===================
+ Mod_DecompressVis
+ ===================
+ */
+ protected 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
+ */
+ protected byte[] Mod_ClusterPVS(int cluster, model_t model) {
+ if (cluster == -1 || model.vis == null)
+ return mod_novis;
+
+ return Mod_DecompressVis(model_visibility, model.vis.bitofs[cluster][Defines.DVIS_PVS], model);
+ }
+
+ /**
+ * Mod_Modellist_f
+ */
+ protected void Mod_Modellist_f() {
+ int i;
+ model_t mod;
+ int total;
+
+ total = 0;
+ VID.Printf(Defines.PRINT_ALL, "Loaded models:\n");
+ for (i = 0; i < mod_numknown; i++) {
+ mod = mod_known[i];
+ if (mod.name.length() == 0)
+ continue;
+
+ VID.Printf(Defines.PRINT_ALL, "%8i : %s\n", new Vargs(2).add(mod.extradatasize).add(mod.name));
+ total += mod.extradatasize;
+ }
+ VID.Printf(Defines.PRINT_ALL, "Total resident: " + total + '\n');
+ }
+
+ /**
+ * Mod_Init.
+ */
+ protected 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);
+ }
+
+ protected byte[] fileBuffer;
+
+ /**
+ * Mod_ForName.
+ *
+ * Loads in a model for the given name.
+ */
+ protected model_t Mod_ForName(String name, boolean crash) {
+ model_t mod = null;
+ int i;
+
+ if (name == null || name.length() == 0)
+ Com.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)
+ Com.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.length() == 0)
+ 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.length() == 0)
+ break; // free spot
+ }
+ if (i == mod_numknown) {
+ if (mod_numknown == MAX_MOD_KNOWN)
+ Com.Error(Defines.ERR_DROP, "mod_numknown == MAX_MOD_KNOWN");
+ mod_numknown++;
+ mod = mod_known[i];
+ }
+
+ mod.name = name;
+
+ //
+ // load the file
+ //
+ fileBuffer = FS.LoadFile(name);
+
+ if (fileBuffer == null) {
+ if (crash)
+ Com.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:
+ Com.Error(Defines.ERR_DROP, "Mod_NumForName: unknown fileid for " + mod.name);
+ break;
+ }
+
+ this.fileBuffer = null; // free it for garbage collection
+ return mod;
+ }
+
+ /*
+ * ===============================================================================
+ *
+ * BRUSHMODEL LOADING
+ *
+ * ===============================================================================
+ */
+
+ protected byte[] mod_base;
+
+ /**
+ * Mod_LoadLighting.
+ */
+ protected void Mod_LoadLighting(lump_t l) {
+ if (l.filelen == 0) {
+ loadmodel.lightdata = null;
+ return;
+ }
+ loadmodel.lightdata = new byte[l.filelen];
+ System.arraycopy(mod_base, l.fileofs, loadmodel.lightdata, 0, l.filelen);
+ }
+
+ /**
+ * Mod_LoadVisibility.
+ */
+ protected void Mod_LoadVisibility(lump_t l) {
+
+ 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));
+
+ }
+
+ /**
+ * Mod_LoadVertexes.
+ */
+ protected void Mod_LoadVertexes(lump_t l) {
+ mvertex_t[] vertexes;
+ int i, count;
+
+ if ((l.filelen % mvertex_t.DISK_SIZE) != 0)
+ Com.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
+ */
+ protected 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.
+ */
+ protected void Mod_LoadSubmodels(lump_t l) {
+
+ if ((l.filelen % qfiles.dmodel_t.SIZE) != 0)
+ Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name);
+
+ int i, j;
+
+ int count = l.filelen / qfiles.dmodel_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ mmodel_t out;
+ mmodel_t[] outs = new mmodel_t[count];
+ for (i = 0; i < count; i++) {
+ outs[i] = new mmodel_t();
+ }
+
+ loadmodel.submodels = outs;
+ loadmodel.numsubmodels = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ qfiles.dmodel_t in;
+
+ for (i = 0; i < count; i++) {
+ in = new qfiles.dmodel_t(bb);
+ out = outs[i];
+ for (j = 0; j < 3; j++) { // spread the mins / maxs by a
+ // pixel
+ out.mins[j] = in.mins[j] - 1;
+ out.maxs[j] = in.maxs[j] + 1;
+ out.origin[j] = in.origin[j];
+ }
+ out.radius = RadiusFromBounds(out.mins, out.maxs);
+ out.headnode = in.headnode;
+ out.firstface = in.firstface;
+ out.numfaces = in.numfaces;
+ }
+ }
+
+ /*
+ * ================= Mod_LoadEdges =================
+ */
+ protected void Mod_LoadEdges(lump_t l) {
+ medge_t[] edges;
+ int i, count;
+
+ if ((l.filelen % medge_t.DISK_SIZE) != 0)
+ Com.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 =================
+ */
+ protected 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)
+ Com.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, Base.it_wall);
+ if (out[i].image == null) {
+ VID.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[]
+ ================
+ */
+ protected void CalcSurfaceExtents(msurface_t s) {
+ float[] mins = { 0, 0 };
+ float[] maxs = { 0, 0 };
+ float val;
+
+ int j, e;
+ mvertex_t v;
+ int[] bmins = { 0, 0 };
+ int[] bmaxs = { 0, 0 };
+
+ mins[0] = mins[1] = 999999;
+ maxs[0] = maxs[1] = -99999;
+
+ mtexinfo_t tex = s.texinfo;
+
+ for (int 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 (int 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 =================
+ */
+ protected void Mod_LoadFaces(lump_t l) {
+
+ int i, surfnum;
+ int planenum, side;
+ int ti;
+
+ if ((l.filelen % qfiles.dface_t.SIZE) != 0)
+ Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in "
+ + loadmodel.name);
+
+ int count = l.filelen / qfiles.dface_t.SIZE;
+ // out = Hunk_Alloc ( count*sizeof(*out));
+ msurface_t[] outs = new msurface_t[count];
+ for (i = 0; i < count; i++) {
+ outs[i] = new msurface_t();
+ }
+
+ loadmodel.surfaces = outs;
+ loadmodel.numsurfaces = count;
+
+ ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+
+ currentmodel = loadmodel;
+
+ GL_BeginBuildingLightmaps(loadmodel);
+
+ qfiles.dface_t in;
+ msurface_t out;
+
+ for (surfnum = 0; surfnum < count; surfnum++) {
+ in = new qfiles.dface_t(bb);
+ out = outs[surfnum];
+ out.firstedge = in.firstedge;
+ out.numedges = in.numedges;
+ out.flags = 0;
+ out.polys = null;
+
+ planenum = in.planenum;
+ side = in.side;
+ if (side != 0)
+ out.flags |= Defines.SURF_PLANEBACK;
+
+ out.plane = loadmodel.planes[planenum];
+
+ ti = in.texinfo;
+ if (ti < 0 || ti >= loadmodel.numtexinfo)
+ Com.Error(Defines.ERR_DROP,
+ "MOD_LoadBmodel: bad texinfo number");
+
+ out.texinfo = loadmodel.texinfo[ti];
+
+ CalcSurfaceExtents(out);
+
+ // lighting info
+
+ for (i = 0; i < Defines.MAXLIGHTMAPS; i++)
+ out.styles[i] = in.styles[i];
+
+ i = in.lightofs;
+ if (i == -1)
+ out.samples = null;
+ else {
+ ByteBuffer pointer = ByteBuffer.wrap(loadmodel.lightdata);
+ pointer.position(i);
+ pointer = pointer.slice();
+ pointer.mark();
+ out.samples = pointer; // subarray
+ }
+
+ // set the drawing flags
+
+ if ((out.texinfo.flags & Defines.SURF_WARP) != 0) {
+ out.flags |= Defines.SURF_DRAWTURB;
+ for (i = 0; i < 2; i++) {
+ out.extents[i] = 16384;
+ out.texturemins[i] = -8192;
+ }
+ GL_SubdivideSurface(out); // cut up polygon for warps
+ }
+
+ // create lightmaps and polygons
+ if ((out.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33
+ | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0)
+ GL_CreateSurfaceLightmap(out);
+
+ if ((out.texinfo.flags & Defines.SURF_WARP) == 0)
+ GL_BuildPolygonFromSurface(out);
+
+ }
+ GL_EndBuildingLightmaps();
+ }
+
+ /*
+ * ================= Mod_SetParent =================
+ */
+ protected 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 =================
+ */
+ protected 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)
+ Com.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 =================
+ */
+ protected 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)
+ Com.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 =================
+ */
+ protected void Mod_LoadMarksurfaces(lump_t l) {
+ int i, j, count;
+
+ msurface_t[] out;
+
+ if ((l.filelen % Defines.SIZE_OF_SHORT) != 0)
+ Com.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)
+ Com.Error(Defines.ERR_DROP,
+ "Mod_ParseMarksurfaces: bad surface number");
+
+ out[i] = loadmodel.surfaces[j];
+ }
+ }
+
+ /*
+ * ================= Mod_LoadSurfedges =================
+ */
+ protected void Mod_LoadSurfedges(lump_t l) {
+ int i, count;
+ int[] offsets;
+
+ if ((l.filelen % Defines.SIZE_OF_INT) != 0)
+ Com.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)
+ Com.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 =================
+ */
+ protected 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)
+ Com.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];
+ for (i = 0; i < count; i++) {
+ out[i] = new cplane_t();
+ }
+
+ 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);
+ 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 =================
+ */
+ protected void Mod_LoadBrushModel(model_t mod, ByteBuffer buffer) {
+ int i;
+ qfiles.dheader_t header;
+ mmodel_t bm;
+
+ loadmodel.type = Base.mod_brush;
+ if (loadmodel != mod_known[0])
+ Com.Error(Defines.ERR_DROP, "Loaded a brush model after the world");
+
+ header = new qfiles.dheader_t(buffer);
+
+ i = header.version;
+ if (i != Defines.BSPVERSION)
+ Com.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)
+ Com.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.
+ */
+ protected 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)
+ Com.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 > Base.MAX_LBM_HEIGHT)
+ Com.Error(Defines.ERR_DROP, "model " + mod.name
+ + " has a skin taller than " + Base.MAX_LBM_HEIGHT);
+
+ if (pheader.num_xyz <= 0)
+ Com.Error(Defines.ERR_DROP, "model " + mod.name
+ + " has no vertices");
+
+ if (pheader.num_xyz > qfiles.MAX_VERTS)
+ Com.Error(Defines.ERR_DROP, "model " + mod.name
+ + " has too many vertices");
+
+ if (pheader.num_st <= 0)
+ Com.Error(Defines.ERR_DROP, "model " + mod.name
+ + " has no st vertices");
+
+ if (pheader.num_tris <= 0)
+ Com.Error(Defines.ERR_DROP, "model " + mod.name
+ + " has no triangles");
+
+ if (pheader.num_frames <= 0)
+ Com.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 int[pheader.num_xyz];
+ for (int k = 0; k < pheader.num_xyz; k++) {
+ poutframe[i].verts[k] = buffer.getInt();
+ }
+ }
+
+ mod.type = Base.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);
+ int n = skinNames[i].indexOf('\0');
+ if (n > -1) {
+ skinNames[i] = skinNames[i].substring(0, n);
+ }
+ mod.skins[i] = GL_FindImage(skinNames[i], Base.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;
+
+ if (fastjogl)
+ precompileGLCmds(pheader);
+ }
+
+ boolean fastjogl = true;
+
+ /*
+ * ==============================================================================
+ *
+ * SPRITE MODELS
+ *
+ * ==============================================================================
+ */
+
+ /*
+ * ================= Mod_LoadSpriteModel =================
+ */
+ protected void Mod_LoadSpriteModel(model_t mod, ByteBuffer buffer) {
+ qfiles.dsprite_t sprout = new qfiles.dsprite_t(buffer);
+
+ if (sprout.version != qfiles.SPRITE_VERSION)
+ Com.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)
+ Com.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, Base.it_sprite);
+ }
+
+ mod.type = Base.mod_sprite;
+ mod.extradata = sprout;
+ }
+
+ // =============================================================================
+
+ /*
+ * @@@@@@@@@@@@@@@@@@@@@
+ * R_BeginRegistration
+ *
+ * Specifies the model that will be used as the world
+ * @@@@@@@@@@@@@@@@@@@@@
+ */
+ protected void R_BeginRegistration(String model) {
+
+ if (fastjogl)
+ resetModelArrays();
+
+ Polygon.reset();
+
+ 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 = 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 == Base.mod_sprite) {
+ sprout = (qfiles.dsprite_t) mod.extradata;
+ for (i = 0; i < sprout.numframes; i++)
+ mod.skins[i] = GL_FindImage(sprout.frames[i].name,
+ Base.it_sprite);
+ } else if (mod.type == Base.mod_alias) {
+ pheader = (qfiles.dmdl_t) mod.extradata;
+ for (i = 0; i < pheader.num_skins; i++)
+ mod.skins[i] = GL_FindImage(pheader.skinNames[i],
+ Base.it_skin);
+ // PGM
+ mod.numframes = pheader.num_frames;
+ // PGM
+ } else if (mod.type == Base.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.length() == 0)
+ continue;
+ if (mod.registration_sequence != registration_sequence) { // don't
+ // need
+ // this
+ // model
+ Mod_Free(mod);
+ } else {
+ // precompile AliasModels
+ if (fastjogl)
+ if (mod.type == Base.mod_alias)
+ precompileGLCmds((qfiles.dmdl_t) mod.extradata);
+ }
+ }
+ GL_FreeUnusedImages();
+
+ // modelMemoryUsage();
+ }
+
+ // =============================================================================
+
+ /*
+ * ================ Mod_Free ================
+ */
+ protected void Mod_Free(model_t mod) {
+ mod.clear();
+ }
+
+ /*
+ * ================ Mod_FreeAll ================
+ */
+ protected 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
+ */
+ protected static final int MODEL_BUFFER_SIZE = 50000;
+
+ protected static FloatBuffer globalModelTextureCoordBuf =
+ BufferUtils.newFloatBuffer(MODEL_BUFFER_SIZE * 2);
+
+ protected static IntBuffer globalModelVertexIndexBuf =
+ BufferUtils.newIntBuffer(MODEL_BUFFER_SIZE);
+
+ protected 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();
+ model.indexElements[i].limit(count);
+ pos += count;
+ }
+ }
+
+ protected static void resetModelArrays() {
+ globalModelTextureCoordBuf.rewind();
+ globalModelVertexIndexBuf.rewind();
+ }
+
+ protected static void modelMemoryUsage() {
+ System.out.println("AliasModels: globalVertexBuffer size "
+ + globalModelVertexIndexBuf.position());
+ }
+}
diff --git a/src/jake2/render/common/Polygon.java b/src/jake2/render/common/Polygon.java
new file mode 100644
index 0000000..38537d9
--- /dev/null
+++ b/src/jake2/render/common/Polygon.java
@@ -0,0 +1,164 @@
+/*
+ * Polygon.java
+ * Copyright (C) 2003
+ *
+ * $Id: Polygon.java,v 1.1 2006-10-31 13:06:32 salomo 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.common;
+
+import jake2.render.glpoly_t;
+import jake2.util.Lib;
+
+import java.nio.FloatBuffer;
+
+/**
+ * Polygon
+ *
+ * @author cwei
+ */
+public final class Polygon extends glpoly_t {
+
+ private final static int MAX_POLYS = 20000;
+
+ private final static int MAX_BUFFER_VERTICES = 120000;
+
+ // backup for s1 scrolling
+ private static float[] s1_old = new float[MAX_VERTICES];
+
+ private static FloatBuffer buffer = Lib.newFloatBuffer(MAX_BUFFER_VERTICES * STRIDE);
+
+ private static int bufferIndex = 0;
+
+ private static int polyCount = 0;
+
+ private static Polygon[] polyCache = new Polygon[MAX_POLYS];
+
+ static {
+ for (int i = 0; i < polyCache.length; i++) {
+ polyCache[i] = new Polygon();
+ }
+ }
+
+ public static glpoly_t create(int numverts) {
+ Polygon poly = polyCache[polyCount++];
+ poly.clear();
+ poly.numverts = numverts;
+ poly.pos = bufferIndex;
+ bufferIndex += numverts;
+ return poly;
+ }
+
+ static void reset() {
+ polyCount = 0;
+ bufferIndex = 0;
+ }
+
+ public static FloatBuffer getInterleavedBuffer() {
+ return (FloatBuffer) buffer.rewind();
+ }
+
+ private Polygon() {
+ }
+
+ private final void clear() {
+ next = null;
+ chain = null;
+ numverts = 0;
+ flags = 0;
+ }
+
+ // the interleaved buffer has the format:
+ // textureCoord0 (index 0, 1)
+ // vertex (index 2, 3, 4)
+ // textureCoord1 (index 5, 6)
+
+ public final float x(int index) {
+ return buffer.get((index + pos) * 7 + 2);
+ }
+
+ public final void x(int index, float value) {
+ buffer.put((index + pos) * 7 + 2, value);
+ }
+
+ public final float y(int index) {
+ return buffer.get((index + pos) * 7 + 3);
+ }
+
+ public final void y(int index, float value) {
+ buffer.put((index + pos) * 7 + 3, value);
+ }
+
+ public final float z(int index) {
+ return buffer.get((index + pos) * 7 + 4);
+ }
+
+ public final void z(int index, float value) {
+ buffer.put((index + pos) * 7 + 4, value);
+ }
+
+ public final float s1(int index) {
+ return buffer.get((index + pos) * 7 + 0);
+ }
+
+ public final void s1(int index, float value) {
+ buffer.put((index + pos) * 7 + 0, value);
+ }
+
+ public final float t1(int index) {
+ return buffer.get((index + pos) * 7 + 1);
+ }
+
+ public final void t1(int index, float value) {
+ buffer.put((index + pos) * 7 + 1, value);
+ }
+
+ public final float s2(int index) {
+ return buffer.get((index + pos) * 7 + 5);
+ }
+
+ public final void s2(int index, float value) {
+ buffer.put((index + pos) * 7 + 5, value);
+ }
+
+ public final float t2(int index) {
+ return buffer.get((index + pos) * 7 + 6);
+ }
+
+ public final void t2(int index, float value) {
+ buffer.put((index + pos) * 7 + 6, value);
+ }
+
+ public final void beginScrolling(float scroll) {
+ int index = pos * 7;
+ for (int i = 0; i < numverts; i++, index += 7) {
+ scroll += s1_old[i] = buffer.get(index);
+ buffer.put(index, scroll);
+ }
+ }
+
+ public final void endScrolling() {
+ int index = pos * 7;
+ for (int i = 0; i < numverts; i++, index += 7) {
+ buffer.put(index, s1_old[i]);
+ }
+ }
+} \ No newline at end of file
diff --git a/src/jake2/render/common/Surf.java b/src/jake2/render/common/Surf.java
new file mode 100644
index 0000000..b91ad2c
--- /dev/null
+++ b/src/jake2/render/common/Surf.java
@@ -0,0 +1,1212 @@
+/*
+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 20.08.2006 by RST.
+
+// $Id: Surf.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import java.nio.*;
+import java.util.Arrays;
+
+import org.lwjgl.opengl.GL11;
+
+import net.java.games.jogl.GL;
+import net.java.games.jogl.util.BufferUtils;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.render.common.Image.pos_t;
+import jake2.server.*;
+import jake2.util.*;
+
+
+public abstract class Surf extends Draw {
+
+ // GL_RSURF.C: surface-related refresh code
+ protected float[] modelorg = { 0, 0, 0 }; // relative to viewpoint
+
+ protected msurface_t r_alpha_surfaces;
+
+ protected static final int DYNAMIC_LIGHT_WIDTH = 128;
+
+ protected static final int DYNAMIC_LIGHT_HEIGHT = 128;
+
+ protected static final int LIGHTMAP_BYTES = 4;
+
+ protected static final int LM_BLOCK_WIDTH = 128;
+
+ protected static final int LM_BLOCK_HEIGHT = 128;
+
+ protected int c_visible_lightmaps;
+
+ protected int c_visible_textures;
+
+ protected gllightmapstate_t gl_lms = new gllightmapstate_t();
+
+ protected static final int GL_LIGHTMAP_FORMAT = ggl.GL_RGBA;
+
+ public static final int MAX_LIGHTMAPS = 128;
+
+ protected byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8];
+
+ protected lightstyle_t[] lightstyles;
+
+ public static class gllightmapstate_t {
+
+ public int internal_format;
+
+ public int current_lightmap_texture;
+
+ public msurface_t[] lightmap_surfaces = new msurface_t[MAX_LIGHTMAPS];
+
+ public int[] allocated = new int[LM_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];
+ public IntBuffer lightmap_buffer = Lib.newIntBuffer(
+ LM_BLOCK_WIDTH * LM_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();
+ }
+ }
+
+
+ /**
+ * LM_InitBlock
+ */
+ protected void LM_InitBlock() {
+ Arrays.fill(gl_lms.allocated, 0);
+ }
+
+
+ /**
+ * LM_AllocBlock.
+ *
+ */
+ protected boolean LM_AllocBlock(int w, int h, pos_t pos) {
+ int best = LM_BLOCK_HEIGHT;
+ int x = pos.x;
+
+ int best2;
+ int i, j;
+ for (i = 0; i < LM_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 = best = best2;
+ }
+ }
+
+ if (best + h > LM_BLOCK_HEIGHT)
+ return false;
+
+ for (i = 0; i < w; i++)
+ gl_lms.allocated[x + i] = best + h;
+
+ return true;
+ }
+
+ /**
+ * R_TextureAnimation
+ *
+ * Returns the proper texture for a given time and base texture
+ */
+ protected 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.
+ */
+ protected void DrawGLPoly(glpoly_t p) {
+ ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts);
+ }
+
+ /**
+ * DrawGLFlowingPoly version that handles scrolling texture
+ */
+ protected void DrawGLFlowingPoly(glpoly_t p) {
+ float scroll = -64 * ((r_newrefdef.time / 40.0f) - (int) (r_newrefdef.time / 40.0f));
+ if (scroll == 0.0f)
+ scroll = -64.0f;
+ p.beginScrolling(scroll);
+ ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts);
+ p.endScrolling();
+ }
+
+ protected abstract void GL_LoadMatrix();
+
+ /**
+ * 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.
+ */
+ protected void R_DrawAlphaSurfaces() {
+
+ GL_LoadMatrix();
+
+ ggl.glEnable(ggl.GL_BLEND);
+ GL_TexEnv(ggl.GL_MODULATE);
+
+ // the textures are prescaled up for a better lighting range,
+ // so scale it back down
+ float intens = gl_state.inverse_intensity;
+
+ ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE, globalPolygonInterleavedBuf);
+
+ for (msurface_t 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)
+ ggl.glColor4f(intens, intens, intens, 0.33f);
+ else if ((s.texinfo.flags & Defines.SURF_TRANS66) != 0)
+ ggl.glColor4f(intens, intens, intens, 0.66f);
+ else
+ ggl.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(ggl.GL_REPLACE);
+ ggl.glColor4f(1, 1, 1, 1);
+ ggl.glDisable(ggl.GL_BLEND);
+
+ r_alpha_surfaces = null;
+ }
+
+ /**
+ * R_DrawTriangleOutlines
+ */
+ protected void R_DrawTriangleOutlines() {
+ if (gl_showtris.value == 0)
+ return;
+
+ ggl.glDisable(ggl.GL_TEXTURE_2D);
+ ggl.glDisable(ggl.GL_DEPTH_TEST);
+ ggl.glColor4f(1, 1, 1, 1);
+
+ for (int i = 0; i < MAX_LIGHTMAPS; i++) {
+ for (msurface_t surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain) {
+ for (glpoly_t p = surf.polys; p != null; p = p.chain) {
+ for (int j = 2; j < p.numverts; j++) {
+ ggl.glBegin(ggl.GL_LINE_STRIP);
+ ggl.glVertex3f(p.x(0), p.y(0), p.z(0));
+ ggl.glVertex3f(p.x(j-1), p.y(j-1), p.z(j-1));
+ ggl.glVertex3f(p.x(j), p.y(j), p.z(j));
+ ggl.glVertex3f(p.x(0), p.y(0), p.z(0));
+ ggl.glEnd();
+ }
+ }
+ }
+ }
+
+ ggl.glEnable(ggl.GL_DEPTH_TEST);
+ ggl.glEnable(ggl.GL_TEXTURE_2D);
+ }
+
+ /**
+ * R_MarkLeaves -
+ *
+ * Mark the leaves and nodes that are in the PVS for the current cluster.
+ */
+ protected void R_MarkLeaves() {
+
+ 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;
+ }
+
+ byte[] vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel);
+
+ // may have to combine two clusters because of solid water boundaries
+ if (r_viewcluster2 != r_viewcluster) {
+ System .arraycopy(vis, 0, fatvis, 0, (r_worldmodel.numleafs + 7) >> 3);
+ vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel);
+ c = (r_worldmodel.numleafs + 31) >> 5;
+ c <<= 2;
+
+ for (int k = 0; k < c; k+=4) {
+ fatvis[k] |= vis[k];
+ fatvis[k + 1] |= vis[k + 1];
+ fatvis[k + 2] |= vis[k + 2];
+ fatvis[k + 3] |= vis[k + 3];
+ }
+
+ 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);
+ }
+ }
+ }
+
+ // direct buffer
+ protected IntBuffer temp = Lib.newIntBuffer(128 * 128,ByteOrder.LITTLE_ENDIAN);
+
+ protected IntBuffer temp2 = Lib.newIntBuffer(34 * 34, ByteOrder.LITTLE_ENDIAN);
+
+ /*
+ * new buffers for vertex array handling
+ */
+ protected static FloatBuffer globalPolygonInterleavedBuf = Polygon.getInterleavedBuffer();
+
+ protected static FloatBuffer globalPolygonTexCoord1Buf = null;
+
+ static {
+ globalPolygonInterleavedBuf.position(Polygon.STRIDE - 2);
+ globalPolygonTexCoord1Buf = globalPolygonInterleavedBuf.slice();
+ globalPolygonInterleavedBuf.position(0);
+ };
+
+ protected abstract void EmitWaterPolys(msurface_t s);
+ protected abstract void R_BuildLightMap(msurface_t fa, IntBuffer temp22, int smax);
+ protected abstract void R_SetCacheState(msurface_t fa);
+ protected abstract void R_MarkLights(dlight_t lt, int i, mnode_t mnode_t);
+ protected abstract void R_AddSkySurface(msurface_t s);
+ protected abstract void R_DrawSkyBox();
+ protected abstract void R_ClearSkyBox();
+
+ /**
+ * R_RotateForEntity
+ */
+ protected final void R_RotateForEntity(entity_t e) {
+ ggl.glTranslatef(e.origin[0], e.origin[1], e.origin[2]);
+
+ ggl.glRotatef(e.angles[1], 0, 0, 1);
+ ggl.glRotatef(-e.angles[0], 0, 1, 0);
+ ggl.glRotatef(-e.angles[2], 1, 0, 0);
+ }
+
+
+ /**
+ *R_RenderBrushPoly ================
+ */
+ protected 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(ggl.GL_MODULATE);
+ ggl.glColor4f(gl_state.inverse_intensity, gl_state.inverse_intensity, gl_state.inverse_intensity, 1.0F);
+ EmitWaterPolys(fa);
+ GL_TexEnv(ggl.GL_REPLACE);
+
+ return;
+ } else {
+ GL_Bind(image.texnum);
+ GL_TexEnv(ggl.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);
+
+ ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, fa.light_s, fa.light_t,
+ smax, tmax, GL_LIGHTMAP_FORMAT, ggl.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;
+ }
+ }
+
+ IntBuffer dummy = BufferUtils.newIntBuffer(128 * 128);
+
+ /**
+ * GL_BeginBuildingLightmaps.
+ */
+ protected void GL_BeginBuildingLightmaps(model_t m) {
+
+ if (lightstyles == null) {
+ lightstyles = new lightstyle_t[Defines.MAX_LIGHTSTYLES];
+ for (int i = 0; i < lightstyles.length; i++) {
+ lightstyles[i] = new lightstyle_t();
+ }
+ }
+
+ 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 (int 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 = Base.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 = ggl.GL_INTENSITY8;
+ } else if (format == 'L') {
+ gl_lms.internal_format = ggl.GL_LUMINANCE8;
+ } else {
+ gl_lms.internal_format = gl_tex_solid_format;
+ }
+
+ /*
+ * * initialize the dynamic lightmap texture
+ */
+ GL_Bind(gl_state.lightmap_textures + 0);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_LINEAR);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.GL_LINEAR);
+ ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_lms.internal_format,
+ LM_BLOCK_WIDTH, LM_BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT,
+ ggl.GL_UNSIGNED_BYTE, dummy);
+ }
+
+
+ /**
+ * GL_EndBuildingLightmaps.
+ */
+ protected void GL_EndBuildingLightmaps() {
+ LM_UploadBlock(false);
+ GL_EnableMultitexture(false);
+ }
+
+ /**
+ * DrawTextureChains.
+ */
+ protected 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);
+ }
+
+ protected void GL_RenderLightmappedPoly(msurface_t surf) {
+ int map = 0;
+
+ 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;
+
+ ggl.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;
+
+ ggl.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) {
+ p.beginScrolling(scroll);
+ ggl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ p.endScrolling();
+ }
+ } else {
+ for (p = surf.polys; p != null; p = p.chain) {
+ ggl.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) {
+ p.beginScrolling(scroll);
+ ggl.glDrawArrays(GL.GL_POLYGON, p.pos, p.numverts);
+ p.endScrolling();
+ }
+ } else {
+ // PGM
+ // ==========
+ for (p = surf.polys; p != null; p = p.chain) {
+ ggl.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]);
+ }
+ }
+
+ int psurfp = currentmodel.firstmodelsurface;
+ msurface_t[] surfaces;
+ surfaces = currentmodel.surfaces;
+
+ if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) {
+ ggl.glEnable(ggl.GL_BLEND);
+ ggl.glColor4f(1, 1, 1, 0.25f);
+ GL_TexEnv(ggl.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 < -Base.BACKFACE_EPSILON))
+ || ((psurf.flags & Defines.SURF_PLANEBACK) == 0 && (dot > Base.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) {
+ ggl.glDisable(ggl.GL_BLEND);
+ ggl.glColor4f(1, 1, 1, 1);
+ GL_TexEnv(ggl.GL_REPLACE);
+ }
+ }
+
+ /**
+ * R_DrawBrushModel.
+ */
+ protected void R_DrawBrushModel(entity_t e) {
+ if (currentmodel.nummodelsurfaces == 0)
+ return;
+
+ currententity = e;
+ gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
+
+ float[] mins = Vec3Cache.get();
+ float[] maxs = Vec3Cache.get();
+ boolean rotated;
+ if (e.angles[0] != 0 || e.angles[1] != 0 || e.angles[2] != 0) {
+ rotated = true;
+ for (int 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)) {
+ Vec3Cache.release(2); // mins, maxs
+ return;
+ }
+
+ Vec3Cache.release(2); // mins, maxs
+
+ ggl.glColor3f(1, 1, 1);
+
+ Math3D.VectorSubtract(r_newrefdef.vieworg, e.origin, modelorg);
+ if (rotated) {
+ float[] temp = Vec3Cache.get();
+ float[] forward = Vec3Cache.get();
+ float[] right = Vec3Cache.get();
+ float[] up = Vec3Cache.get();
+
+ 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);
+
+ Vec3Cache.release(4); // temp, forward, right, up
+ }
+
+ ggl.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(ggl.GL_REPLACE);
+ ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE,
+ globalPolygonInterleavedBuf);
+ GL_SelectTexture(GL_TEXTURE1);
+ GL_TexEnv(ggl.GL_MODULATE);
+ ggl.glTexCoordPointer(2, ggl.GL_FLOAT, Polygon.BYTE_STRIDE,
+ globalPolygonTexCoord1Buf);
+ ggl.glEnableClientState(ggl.GL_TEXTURE_COORD_ARRAY);
+
+ R_DrawInlineBModel();
+
+ ggl.glClientActiveTextureARB(GL_TEXTURE1);
+ ggl.glDisableClientState(ggl.GL_TEXTURE_COORD_ARRAY);
+
+ GL_EnableMultitexture(false);
+
+ ggl.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 = 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.
+ */
+ private final entity_t worldEnt = new entity_t();
+
+ protected void R_DrawWorld() {
+
+ if (r_drawworld.value == 0)
+ return;
+
+ if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0)
+ return;
+
+ currentmodel = r_worldmodel;
+
+ Math3D.VectorCopy(r_newrefdef.vieworg, modelorg);
+
+ entity_t ent = worldEnt;
+ // auto cycle the world frame for texture animation
+ ent.clear();
+ ent.frame = (int) (r_newrefdef.time * 2);
+ currententity = ent;
+
+ gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
+
+ ggl.glColor3f(1, 1, 1);
+
+
+ // TODO wird bei multitexture nicht gebraucht
+ //gl_lms.clearLightmapSurfaces();
+
+ R_ClearSkyBox();
+
+ GL_EnableMultitexture(true);
+
+ GL_SelectTexture(GL_TEXTURE0);
+ GL_TexEnv(ggl.GL_REPLACE);
+ ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE,
+ globalPolygonInterleavedBuf);
+ GL_SelectTexture(GL_TEXTURE1);
+ ggl.glTexCoordPointer(2, ggl.GL_FLOAT, Polygon.BYTE_STRIDE,
+ globalPolygonTexCoord1Buf);
+ ggl.glEnableClientState(ggl.GL_TEXTURE_COORD_ARRAY);
+
+ if (gl_lightmap.value != 0)
+ GL_TexEnv(ggl.GL_REPLACE);
+ else
+ GL_TexEnv(ggl.GL_MODULATE);
+
+ R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node
+
+ ggl.glClientActiveTextureARB(GL_TEXTURE1);
+ ggl.glDisableClientState(ggl.GL_TEXTURE_COORD_ARRAY);
+
+ GL_EnableMultitexture(false);
+
+ DrawTextureChains();
+ R_DrawSkyBox();
+ R_DrawTriangleOutlines();
+ }
+
+
+
+
+ /**
+ * LIGHTMAP ALLOCATION
+ *
+ */
+
+ protected 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);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER,
+ ggl.GL_LINEAR);
+ ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER,
+ ggl.GL_LINEAR);
+
+ gl_lms.lightmap_buffer.rewind();
+ if (dynamic) {
+ int i;
+
+ for (i = 0; i < LM_BLOCK_WIDTH; i++) {
+ if (gl_lms.allocated[i] > height)
+ height = gl_lms.allocated[i];
+ }
+
+ ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, 0, 0, LM_BLOCK_WIDTH, height,
+ GL_LIGHTMAP_FORMAT, ggl.GL_UNSIGNED_BYTE,
+ gl_lms.lightmap_buffer);
+ } else {
+ ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_lms.internal_format,
+ LM_BLOCK_WIDTH, LM_BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT,
+ ggl.GL_UNSIGNED_BYTE, gl_lms.lightmap_buffer);
+ if (++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS)
+ Com.Error(Defines.ERR_DROP,
+ "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n");
+
+ //debugLightmap(gl_lms.lightmap_buffer, 128, 128, 4);
+ }
+ }
+
+
+ /**
+ * GL_BuildPolygonFromSurface.
+ */
+ protected void GL_BuildPolygonFromSurface(msurface_t fa) {
+ int i, lindex, lnumverts;
+ medge_t[] pedges;
+ medge_t r_pedge;
+ float[] vec;
+ float s, t;
+ // reconstruct the polygon
+ pedges = currentmodel.edges;
+ lnumverts = fa.numedges;
+
+ //
+ // draw texture
+ //
+ glpoly_t poly = Polygon.create(lnumverts);
+
+ poly.next = fa.polys;
+ poly.flags = fa.flags;
+ fa.polys = poly;
+
+ 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;
+
+ poly.x(i, vec[0]);
+ poly.y(i, vec[1]);
+ poly.z(i, vec[2]);
+ poly.s1(i, s);
+ poly.t1(i, 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 /= LM_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 /= LM_BLOCK_HEIGHT * 16; // fa.texinfo.texture.height;
+
+ poly.s2(i, s);
+ poly.t2(i, t);
+ }
+ }
+
+ /**
+ * GL_CreateSurfaceLightmap.
+ */
+ protected 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)) {
+ Com.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 * LM_BLOCK_WIDTH + surf.light_s);
+
+ R_SetCacheState(surf);
+ R_BuildLightMap(surf, base.slice(), LM_BLOCK_WIDTH);
+ }
+}
diff --git a/src/jake2/render/common/Warp.java b/src/jake2/render/common/Warp.java
new file mode 100644
index 0000000..66612bb
--- /dev/null
+++ b/src/jake2/render/common/Warp.java
@@ -0,0 +1,676 @@
+/*
+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 20.08.2006 by RST.
+// $Id: Warp.java,v 1.1 2006-10-31 13:06:32 salomo Exp $
+
+package jake2.render.common;
+
+
+import net.java.games.jogl.GL;
+import jake2.Defines;
+import jake2.Globals;
+import jake2.qcommon.Com;
+import jake2.render.*;
+import jake2.util.Math3D;
+import jake2.util.Vec3Cache;
+
+
+public abstract class Warp extends Surf {
+ // 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 };
+
+ String skyname;
+
+ protected float skyrotate;
+
+ protected float[] skyaxis = { 0, 0, 0 };
+
+ protected image_t[] sky_images = new image_t[6];
+
+ protected msurface_t warpface;
+
+ protected static final int SUBDIVIDE_SIZE = 64;
+
+ /**
+ * BoundPoly
+ *
+ */
+ protected void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs) {
+ mins[0] = mins[1] = mins[2] = 9999;
+ maxs[0] = maxs[1] = maxs[2] = -9999;
+
+ int j;
+ float[] v;
+ for (int 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];
+ }
+ }
+ }
+
+ /**
+ * SubdividePolygon
+ *
+ */
+ protected void SubdividePolygon(int numverts, float[][] verts) {
+ int i, j, k;
+ float m;
+ float[][] front = new float[64][3];
+ float[][] back = new float[64][3];
+
+ int f, b;
+ float[] dist = new float[64];
+ float frac;
+
+ if (numverts > 60)
+ Com.Error(Defines.ERR_DROP, "numverts = " + numverts);
+
+ float[] mins = Vec3Cache.get();
+ float[] maxs = Vec3Cache.get();
+
+ BoundPoly(numverts, verts, mins, maxs);
+ float[] v;
+ // 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);
+
+ Vec3Cache.release(2); // mins, maxs
+ return;
+ }
+
+ Vec3Cache.release(2); // mins, maxs
+
+ // 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
+ glpoly_t poly = Polygon.create(numverts + 2);
+
+ poly.next = warpface.polys;
+ warpface.polys = poly;
+
+ float[] total = Vec3Cache.get();
+ Math3D.VectorClear(total);
+ float total_s = 0;
+ float total_t = 0;
+ float s, t;
+ for (i = 0; i < numverts; i++) {
+ poly.x(i + 1, verts[i][0]);
+ poly.y(i + 1, verts[i][1]);
+ poly.z(i + 1, verts[i][2]);
+ 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.s1(i + 1, s);
+ poly.t1(i + 1, t);
+ }
+
+ float scale = 1.0f / numverts;
+ poly.x(0, total[0] * scale);
+ poly.y(0, total[1] * scale);
+ poly.z(0, total[2] * scale);
+ poly.s1(0, total_s * scale);
+ poly.t1(0, total_t * scale);
+
+ poly.x(i + 1, poly.x(1));
+ poly.y(i + 1, poly.y(1));
+ poly.z(i + 1, poly.z(1));
+ poly.s1(i + 1, poly.s1(1));
+ poly.t1(i + 1, poly.t1(1));
+ poly.s2(i + 1, poly.s2(1));
+ poly.t2(i + 1, poly.t2(1));
+
+ Vec3Cache.release(); // total
+ }
+
+ private final float[][] tmpVerts = new float[64][3];
+
+ /**
+ * GL_SubdivideSurface Breaks a polygon up along axial 64 unit boundaries so
+ * that turbulent and sky warps can be done reasonably.
+ */
+ protected void GL_SubdivideSurface(msurface_t fa) {
+ float[][] verts = tmpVerts;
+ float[] vec;
+ warpface = fa;
+ //
+ // convert edges back to a normal polygon
+ //
+ int numverts = 0;
+ for (int i = 0; i < fa.numedges; i++) {
+ int 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);
+ }
+
+ protected static final float TURBSCALE = (float) (256.0f / (2 * Math.PI));
+
+ float[][] skyclip = { { 1, 1, 0 }, { 1, -1, 0 }, { 0, -1, 1 }, { 0, 1, 1 }, { 1, 0, 1 }, { -1, 0, 1 } };
+
+ protected int c_sky;
+
+ // 1 = s, 2 = t, 3 = 2048
+ protected 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
+ };
+
+ protected int[][] vec_to_st = {
+ { -2, 3, 1 }, { 2, 3, -1 },
+ { 1, 3, 2 }, { -1, 3, -2 },
+ { -2, -1, 3 }, { -2, 1, -3 }
+ };
+
+ protected float[][] skymins = new float[2][6];
+
+ protected float[][] skymaxs = new float[2][6];
+
+ protected float sky_min, sky_max;
+
+ protected static final float ON_EPSILON = 0.1f; // point on plane side epsilon
+
+ protected static final int MAX_CLIP_VERTS = 64;
+
+ protected static final int SIDE_BACK = 1;
+
+ protected static final int SIDE_FRONT = 0;
+
+ protected static final int SIDE_ON = 2;
+
+ protected float[] dists = new float[MAX_CLIP_VERTS];
+
+ protected int[] sides = new int[MAX_CLIP_VERTS];
+
+ protected float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3];
+
+ /**
+ * ClipSkyPolygon
+ *
+ * @param nump
+ * @param vecs
+ * @param stage
+ */
+ protected void ClipSkyPolygon(int nump, float[][] vecs, int stage) {
+ if (nump > MAX_CLIP_VERTS - 2)
+ Com.Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS");
+ if (stage == 6) { // fully clipped, so draw it
+ DrawSkyPolygon(nump, vecs);
+ return;
+ }
+
+ boolean front = false;
+ boolean back = false;
+ float[] norm = skyclip[stage];
+
+ int i;
+ float d;
+ 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]);
+
+ int newc0 = 0;
+ int newc1 = 0;
+ float[] v;
+ float e;
+ int j;
+ for (i = 0; i < nump; i++) {
+ v = vecs[i];
+ switch (sides[i]) {
+ case SIDE_FRONT:
+ Math3D.VectorCopy(v, newv[stage][0][newc0]);
+ newc0++;
+ break;
+ case SIDE_BACK:
+ Math3D.VectorCopy(v, newv[stage][1][newc1]);
+ newc1++;
+ break;
+ case SIDE_ON:
+ Math3D.VectorCopy(v, newv[stage][0][newc0]);
+ newc0++;
+ Math3D.VectorCopy(v, newv[stage][1][newc1]);
+ newc1++;
+ 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][newc0][j] = e;
+ newv[stage][1][newc1][j] = e;
+ }
+ newc0++;
+ newc1++;
+ }
+
+ // continue
+ ClipSkyPolygon(newc0, newv[stage][0], stage + 1);
+ ClipSkyPolygon(newc1, newv[stage][1], stage + 1);
+ }
+
+ protected float[][] verts = new float[MAX_CLIP_VERTS][3];
+
+
+
+ // stack variable
+ private final float[] v = { 0, 0, 0 };
+
+ private final float[] av = { 0, 0, 0 };
+
+ /**
+ * DrawSkyPolygon
+ *
+ */
+ protected void DrawSkyPolygon(int nump, float[][] vecs) {
+ c_sky++;
+ // decide which face it maps to
+ Math3D.VectorCopy(Globals.vec3_origin, v);
+ int i, axis;
+ 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
+ float s, t, dv;
+ int j;
+ 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;
+ }
+ }
+
+ /**
+ * R_AddSkySurface
+ */
+ protected void R_AddSkySurface(msurface_t fa) {
+ // calculate vertex values for sky box
+ for (glpoly_t p = fa.polys; p != null; p = p.next) {
+ for (int i = 0; i < p.numverts; i++) {
+ verts[i][0] = p.x(i) - r_origin[0];
+ verts[i][1] = p.y(i) - r_origin[1];
+ verts[i][2] = p.z(i) - r_origin[2];
+ }
+ ClipSkyPolygon(p.numverts, verts, 0);
+ }
+ }
+
+ /**
+ * R_ClearSkyBox
+ */
+ protected void R_ClearSkyBox() {
+ float[] skymins0 = skymins[0];
+ float[] skymins1 = skymins[1];
+ float[] skymaxs0 = skymaxs[0];
+ float[] skymaxs1 = skymaxs[1];
+
+ for (int i = 0; i < 6; i++) {
+ skymins0[i] = skymins1[i] = 9999;
+ skymaxs0[i] = skymaxs1[i] = -9999;
+ }
+ }
+
+
+ protected int[] skytexorder = { 0, 2, 1, 3, 4, 5 };
+
+ // 3dstudio environment map names
+ protected String[] suf = { "rt", "bk", "lf", "ft", "up", "dn" };
+
+ /**
+ * R_SetSky
+ *
+ */
+ protected void R_SetSky(String name, float rotate, float[] axis) {
+ assert (axis.length == 3) : "vec3_t bug";
+ String pathname;
+ skyname = name;
+
+ skyrotate = rotate;
+ Math3D.VectorCopy(axis, skyaxis);
+
+ for (int 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, Base.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;
+ }
+ }
+ }
+
+ /**
+ * EmitWaterPolys -
+ * Does a water warp on the pre-fragmented glpoly_t chain.
+ */
+ public void EmitWaterPolys(msurface_t fa) {
+ glpoly_t p, bp;
+ 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;
+
+ for (bp = fa.polys; bp != null; bp = bp.next) {
+ p = bp;
+
+ ggl.glBegin(ggl.GL_TRIANGLE_FAN);
+ for (int i = 0; i < p.numverts; i++) {
+ os = p.s1(i);
+ ot = p.t1(i);
+
+ 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);
+
+ ggl.glTexCoord2f(s, t);
+ ggl.glVertex3f(p.x(i), p.y(i), p.z(i));
+ }
+ ggl.glEnd();
+ }
+ }
+
+ // stack variable
+ private final float[] v1 = {0, 0, 0};
+ private final float[] b = {0, 0, 0};
+ /**
+ * MakeSkyVec
+ * @param s
+ * @param t
+ * @param axis
+ */
+ protected void MakeSkyVec(float s, float t, int axis)
+ {
+ b[0] = s*2300;
+ b[1] = t*2300;
+ b[2] = 2300;
+
+ int j, k;
+ for (j=0 ; j<3 ; j++)
+ {
+ k = st_to_vec[axis][j];
+ if (k < 0)
+ v1[j] = -b[-k - 1];
+ else
+ v1[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;
+ ggl.glTexCoord2f (s, t);
+ ggl.glVertex3f(v1[0], v1[1], v1[2]);
+ }
+
+ /*
+ * ============== R_DrawSkyBox ==============
+ */
+ protected 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
+ }
+
+ ggl.glPushMatrix();
+ ggl.glTranslatef(r_origin[0], r_origin[1], r_origin[2]);
+ ggl.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);
+
+ ggl.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);
+ ggl.glEnd();
+ }
+ ggl.glPopMatrix();
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-11 11:33:58 +0000