/* 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 02.01.2004 by RST. // $Id: CM.java,v 1.1 2004-07-07 19:59:29 hzi Exp $ package jake2.qcommon; import jake2.Defines; import jake2.game.*; import jake2.util.Lib; import jake2.util.Math3D; import jake2.util.Vargs; import java.io.FileNotFoundException; import java.io.RandomAccessFile; import java.nio.*; import java.util.Arrays; public class CM extends Game { public static class cnode_t { cplane_t plane; // ptr int children[] = { 0, 0 }; // negative numbers are leafs } public static class cbrushside_t { cplane_t plane; // ptr mapsurface_t surface; // ptr } public static class cleaf_t { int contents; int cluster; int area; // was unsigned short, but is ok (rst) short firstleafbrush; // was unsigned short, but is ok (rst) short numleafbrushes; } public static class cbrush_t { int contents; int numsides; int firstbrushside; int checkcount; // to avoid repeated testings } public static class carea_t { int numareaportals; int firstareaportal; int floodnum; // if two areas have equal floodnums, they are connected int floodvalid; } static int checkcount; static String map_name = ""; static int numbrushsides; static cbrushside_t map_brushsides[] = new cbrushside_t[MAX_MAP_BRUSHSIDES]; static { for (int n = 0; n < MAX_MAP_BRUSHSIDES; n++) map_brushsides[n] = new cbrushside_t(); } public static int numtexinfo; public static mapsurface_t map_surfaces[] = new mapsurface_t[MAX_MAP_TEXINFO]; static { for (int n = 0; n < MAX_MAP_TEXINFO; n++) map_surfaces[n] = new mapsurface_t(); } static int numplanes; // extra for box hull ( +6) static cplane_t map_planes[] = new cplane_t[MAX_MAP_PLANES + 6]; static { for (int n = 0; n < MAX_MAP_PLANES + 6; n++) map_planes[n] = new cplane_t(); } static int numnodes; // extra for box hull ( +6) static cnode_t map_nodes[] = new cnode_t[MAX_MAP_NODES + 6]; static { for (int n = 0; n < MAX_MAP_NODES + 6; n++) map_nodes[n] = new cnode_t(); } static int numleafs = 1; // allow leaf funcs to be called without a map static cleaf_t map_leafs[] = new cleaf_t[MAX_MAP_LEAFS]; static { for (int n = 0; n < MAX_MAP_LEAFS; n++) map_leafs[n] = new cleaf_t(); } static int emptyleaf, solidleaf; static int numleafbrushes; //static unsigned short map_leafbrushes[MAX_MAP_LEAFBRUSHES]; public static int map_leafbrushes[] = new int[MAX_MAP_LEAFBRUSHES]; public static int numcmodels; public static cmodel_t map_cmodels[] = new cmodel_t[MAX_MAP_MODELS]; static { for (int n = 0; n < MAX_MAP_MODELS; n++) map_cmodels[n] = new cmodel_t(); } public static int numbrushes; public static cbrush_t map_brushes[] = new cbrush_t[MAX_MAP_BRUSHES]; static { for (int n = 0; n < MAX_MAP_BRUSHES; n++) map_brushes[n] = new cbrush_t(); } public static int numvisibility; public static byte map_visibility[] = new byte[MAX_MAP_VISIBILITY]; // main visibility data. rst // was: static dvis_t *map_vis = (dvis_t *)map_visibility; public static qfiles.dvis_t map_vis = new qfiles.dvis_t(ByteBuffer.wrap(map_visibility)); public static int numentitychars; public static String map_entitystring; public static int numareas = 1; public static carea_t map_areas[] = new carea_t[MAX_MAP_AREAS]; static { for (int n = 0; n < MAX_MAP_AREAS; n++) map_areas[n] = new carea_t(); } public static int numareaportals; public static qfiles.dareaportal_t map_areaportals[] = new qfiles.dareaportal_t[MAX_MAP_AREAPORTALS]; static { for (int n = 0; n < MAX_MAP_AREAPORTALS; n++) map_areaportals[n] = new qfiles.dareaportal_t(); } public static int numclusters = 1; public static mapsurface_t nullsurface = new mapsurface_t(); public static int floodvalid; public static boolean portalopen[] = new boolean[MAX_MAP_AREAPORTALS]; public static cvar_t map_noareas; public static int c_pointcontents; public static int c_traces, c_brush_traces; /* =============================================================================== MAP LOADING =============================================================================== */ public static byte cmod_base[]; // is that right (rst) ? public static int checksum; public static int last_checksum; /* ================== CM_LoadMap Loads in the map and all submodels ================== */ public static cmodel_t CM_LoadMap(String name, boolean clientload, intwrap checksum) { Com.DPrintf("CM_LoadMap...\n"); byte buf[]; int i; qfiles.dheader_t header; int length; map_noareas = Cvar.Get("map_noareas", "0", 0); if (0 == strcmp(map_name, name) && (clientload || 0 == Cvar.VariableValue("flushmap"))) { checksum.i = last_checksum; if (!clientload) { Arrays.fill(portalopen, false); FloodAreaConnections(); } return map_cmodels[0]; // still have the right version } // free old stuff numnodes = 0; numleafs = 0; numcmodels = 0; numvisibility = 0; numentitychars = 0; map_entitystring = ""; map_name = ""; if (name == null || name.length() == 0) { numleafs = 1; numclusters = 1; numareas = 1; checksum.i = 0; return map_cmodels[0]; // cinematic servers won't have anything at all } // // load the file // buf = FS.LoadFile(name); if (buf == null) Com.Error(ERR_DROP, "Couldn't load " + name); length = buf.length; ByteBuffer bbuf = ByteBuffer.wrap(buf); last_checksum = MD4.Com_BlockChecksum(buf, length); checksum.i = last_checksum; header = new qfiles.dheader_t(bbuf.slice()); if (header.version != BSPVERSION) Com.Error( ERR_DROP, "CMod_LoadBrushModel: " + name + " has wrong version number (" + header.version + " should be " + BSPVERSION + ")"); cmod_base = buf; // load into heap CMod_LoadSurfaces(header.lumps[LUMP_TEXINFO]); // ok. CMod_LoadLeafs(header.lumps[LUMP_LEAFS]); CMod_LoadLeafBrushes(header.lumps[LUMP_LEAFBRUSHES]); CMod_LoadPlanes(header.lumps[LUMP_PLANES]); CMod_LoadBrushes(header.lumps[LUMP_BRUSHES]); CMod_LoadBrushSides(header.lumps[LUMP_BRUSHSIDES]); CMod_LoadSubmodels(header.lumps[LUMP_MODELS]); CMod_LoadNodes(header.lumps[LUMP_NODES]); CMod_LoadAreas(header.lumps[LUMP_AREAS]); CMod_LoadAreaPortals(header.lumps[LUMP_AREAPORTALS]); CMod_LoadVisibility(header.lumps[LUMP_VISIBILITY]); CMod_LoadEntityString(header.lumps[LUMP_ENTITIES]); FS.FreeFile(buf); CM_InitBoxHull(); Arrays.fill(portalopen, false); FloodAreaConnections(); map_name = name; // debug (rst) Com.p("Testing pointleafes:"); for (int n = 0; n < 20; n++) { float pos[] = new float[] {(float) (Math.random() * 1000), (float) (Math.random() * 1000), 0 }; int x = CM_PointLeafnum(pos); Com.p(Lib.vtofsbeaty(pos) + " ---> leaf=" + x + " area = " +map_leafs[x].area); } return map_cmodels[0]; } /* ================= CMod_LoadSubmodels ================= */ public static void CMod_LoadSubmodels(lump_t l) { Com.DPrintf("CMod_LoadSubmodels...\n"); qfiles.dmodel_t in; cmodel_t out; int i, j, count; if ((l.filelen % qfiles.dmodel_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dmodel_t.SIZE; if (count < 1) Com.Error(ERR_DROP, "Map with no models"); if (count > MAX_MAP_MODELS) Com.Error(ERR_DROP, "Map has too many models"); Com.DPrintf(" numcmodels=" + count + "\n"); numcmodels = count; if (debugloadmap) { Com.DPrintf("submodles(headnode, , , )\n"); } for (i = 0; i < count; i++) { in = new qfiles.dmodel_t(ByteBuffer.wrap(cmod_base, i * qfiles.dmodel_t.SIZE + l.fileofs, qfiles.dmodel_t.SIZE)); out = map_cmodels[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.headnode = in.headnode; if (debugloadmap) { Com.DPrintf( "|%6i|%8.2f|%8.2f|%8.2f| %8.2f|%8.2f|%8.2f| %8.2f|%8.2f|%8.2f|\n", new Vargs() .add(out.headnode) .add(out.origin[0]) .add(out.origin[1]) .add(out.origin[2]) .add(out.mins[0]) .add(out.mins[1]) .add(out.mins[2]) .add(out.maxs[0]) .add(out.maxs[1]) .add(out.maxs[2])); } } } static boolean debugloadmap = false; /* ================= CMod_LoadSurfaces ================= */ public static void CMod_LoadSurfaces(lump_t l) { Com.DPrintf("CMod_LoadSurfaces...\n"); texinfo_t in; mapsurface_t out; int i, count; if ((l.filelen % texinfo_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / texinfo_t.SIZE; if (count < 1) Com.Error(ERR_DROP, "Map with no surfaces"); if (count > MAX_MAP_TEXINFO) Com.Error(ERR_DROP, "Map has too many surfaces"); numtexinfo = count; Com.DPrintf("numtexinfo=" + count + "\n"); if (debugloadmap) Com.DPrintf("surfaces:\n"); for (i = 0; i < count; i++) { out = map_surfaces[i] = new mapsurface_t(); in = new texinfo_t(cmod_base, l.fileofs + i * texinfo_t.SIZE, texinfo_t.SIZE); out.c.name = in.texture; out.rname = in.texture; out.c.flags = in.flags; out.c.value = in.value; if (debugloadmap) { Com.DPrintf("|%20s|%20s|%6i|%6i|\n", new Vargs().add(out.c.name).add(out.rname).add(out.c.value).add(out.c.flags)); } } } /* ================= CMod_LoadNodes ================= */ public static void CMod_LoadNodes(lump_t l) { Com.DPrintf("CMod_LoadNodes...\n"); qfiles.dnode_t in; int child; cnode_t out; int i, j, count; if ((l.filelen % qfiles.dnode_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size:" + l.fileofs + "," + qfiles.dnode_t.SIZE); count = l.filelen / qfiles.dnode_t.SIZE; if (count < 1) Com.Error(ERR_DROP, "Map has no nodes"); if (count > MAX_MAP_NODES) Com.Error(ERR_DROP, "Map has too many nodes"); numnodes = count; Com.DPrintf(" numnodes=" + count + "\n"); if (debugloadmap) { Com.DPrintf("nodes(planenum, child[0], child[1])\n"); } for (i = 0; i < count; i++) { in = new qfiles.dnode_t(ByteBuffer.wrap(cmod_base, qfiles.dnode_t.SIZE * i + l.fileofs, qfiles.dnode_t.SIZE)); out = map_nodes[i]; out.plane = map_planes[in.planenum]; for (j = 0; j < 2; j++) { child = in.children[j]; out.children[j] = child; } if (debugloadmap) { Com.DPrintf("|%6i| %6i| %6i|\n", new Vargs().add(in.planenum).add(out.children[0]).add(out.children[1])); } } } /* ================= CMod_LoadBrushes ================= */ public static void CMod_LoadBrushes(lump_t l) { Com.DPrintf("CMod_LoadBrushes...\n"); qfiles.dbrush_t in; cbrush_t out; int i, count; if ((l.filelen % qfiles.dbrush_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dbrush_t.SIZE; if (count > MAX_MAP_BRUSHES) Com.Error(ERR_DROP, "Map has too many brushes"); numbrushes = count; Com.DPrintf(" numbrushes=" + count + "\n"); if (debugloadmap) { Com.DPrintf("brushes:(firstbrushside, numsides, contents)\n"); } for (i = 0; i < count; i++) { in = new qfiles.dbrush_t(ByteBuffer.wrap(cmod_base, i * qfiles.dbrush_t.SIZE + l.fileofs, qfiles.dbrush_t.SIZE)); out = map_brushes[i]; out.firstbrushside = in.firstside; out.numsides = in.numsides; out.contents = in.contents; if (debugloadmap) { Com.DPrintf("| %6i| %6i| %8X|\n", new Vargs().add(out.firstbrushside).add(out.numsides).add(out.contents)); } } } /* ================= CMod_LoadLeafs ================= */ public static void CMod_LoadLeafs(lump_t l) { Com.DPrintf("CMod_LoadLeafs...\n"); int i; cleaf_t out; qfiles.dleaf_t in; int count; if ((l.filelen % qfiles.dleaf_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dleaf_t.SIZE; if (count < 1) Com.Error(ERR_DROP, "Map with no leafs"); // need to save space for box planes if (count > MAX_MAP_PLANES) Com.Error(ERR_DROP, "Map has too many planes"); Com.DPrintf(" numleafes=" + count + "\n"); numleafs = count; numclusters = 0; if (debugloadmap) Com.DPrintf("cleaf-list:(contents, cluster, area, firstleafbrush, numleafbrushes)\n"); for (i = 0; i < count; i++) { in = new qfiles.dleaf_t(cmod_base, i * qfiles.dleaf_t.SIZE + l.fileofs, qfiles.dleaf_t.SIZE); out = map_leafs[i]; out.contents = in.contents; out.cluster = in.cluster; out.area = in.area; out.firstleafbrush = (short) in.firstleafbrush; out.numleafbrushes = (short) in.numleafbrushes; if (out.cluster >= numclusters) numclusters = out.cluster + 1; if (debugloadmap) { Com.DPrintf( "|%8x|%6i|%6i|%6i|\n", new Vargs().add(out.contents).add(out.cluster).add(out.area).add(out.firstleafbrush).add(out.numleafbrushes)); } } Com.DPrintf(" numclusters=" + numclusters + "\n"); if (map_leafs[0].contents != CONTENTS_SOLID) Com.Error(ERR_DROP, "Map leaf 0 is not CONTENTS_SOLID"); solidleaf = 0; emptyleaf = -1; for (i = 1; i < numleafs; i++) { if (map_leafs[i].contents == 0) { emptyleaf = i; break; } } if (emptyleaf == -1) Com.Error(ERR_DROP, "Map does not have an empty leaf"); } /* ================= CMod_LoadPlanes ================= */ public static void CMod_LoadPlanes(lump_t l) { Com.DPrintf("CMod_LoadPlanes...\n"); int i, j; cplane_t out; qfiles.dplane_t in; int count; int bits; if ((l.filelen % qfiles.dplane_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dplane_t.SIZE; if (count < 1) Com.Error(ERR_DROP, "Map with no planes"); // need to save space for box planes if (count > MAX_MAP_PLANES) Com.Error(ERR_DROP, "Map has too many planes"); Com.DPrintf(" numplanes=" + count + "\n"); numplanes = count; if (debugloadmap) { Com.DPrintf("cplanes(normal[0],normal[1],normal[2], dist, type, signbits)\n"); } for (i = 0; i < count; i++) { in = new qfiles.dplane_t(ByteBuffer.wrap(cmod_base, i * qfiles.dplane_t.SIZE + l.fileofs, qfiles.dplane_t.SIZE)); out = map_planes[i]; bits = 0; for (j = 0; j < 3; j++) { out.normal[j] = in.normal[j]; if (out.normal[j] < 0) bits |= 1 << j; } out.dist = in.dist; out.type = (byte) in.type; out.signbits = (byte) bits; if (debugloadmap) { Com.DPrintf( "|%6.2f|%6.2f|%6.2f| %10.2f|%3i| %1i|\n", new Vargs().add(out.normal[0]).add(out.normal[1]).add(out.normal[2]).add(out.dist).add(out.type).add( out.signbits)); } } } /* ================= CMod_LoadLeafBrushes ================= */ public static void CMod_LoadLeafBrushes(lump_t l) { Com.DPrintf("CMod_LoadLeafBrushes...\n"); int i; int out[]; short in[]; int count; if ((l.filelen % 2) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / 2; Com.DPrintf(" numbrushes=" + count + "\n"); if (count < 1) Com.Error(ERR_DROP, "Map with no planes"); // need to save space for box planes if (count > MAX_MAP_LEAFBRUSHES) Com.Error(ERR_DROP, "Map has too many leafbrushes"); out = map_leafbrushes; numleafbrushes = count; ByteBuffer bb = ByteBuffer.wrap(cmod_base, l.fileofs, count * 2).order(ByteOrder.LITTLE_ENDIAN); if (debugloadmap) { Com.DPrintf("map_brushes:\n"); } for (i = 0; i < count; i++) { out[i] = bb.getShort(); if (debugloadmap) { Com.DPrintf("|%6i|%6i|\n", new Vargs().add(i).add(out[i])); } } } /* ================= CMod_LoadBrushSides ================= */ public static void CMod_LoadBrushSides(lump_t l) { Com.DPrintf("CMod_LoadBrushSides...\n"); int i, j; cbrushside_t out; qfiles.dbrushside_t in; int count; int num; if ((l.filelen % qfiles.dbrushside_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dbrushside_t.SIZE; // need to save space for box planes if (count > MAX_MAP_BRUSHSIDES) Com.Error(ERR_DROP, "Map has too many planes"); numbrushsides = count; Com.DPrintf(" numbrushsides=" + count + "\n"); if (debugloadmap) { Com.DPrintf("brushside(planenum, surfacenum):\n"); } for (i = 0; i < count; i++) { in = new qfiles.dbrushside_t( ByteBuffer.wrap(cmod_base, i * qfiles.dbrushside_t.SIZE + l.fileofs, qfiles.dbrushside_t.SIZE)); out = map_brushsides[i]; num = in.planenum; out.plane = map_planes[num]; // pointer j = in.texinfo; if (j >= numtexinfo) Com.Error(ERR_DROP, "Bad brushside texinfo"); // rst: some mysterious happens here, even in the original code ???, texinfo is -1!!! // hoz: checked against c version: ok. if (j == -1) out.surface = new mapsurface_t(); // just for safety else out.surface = map_surfaces[j]; if (debugloadmap) { Com.DPrintf("| %6i| %6i|\n", new Vargs().add(num).add(j)); } } } /* ================= CMod_LoadAreas ================= */ public static void CMod_LoadAreas(lump_t l) { Com.DPrintf("CMod_LoadAreas...\n"); int i; carea_t out; qfiles.darea_t in; int count; if ((l.filelen % qfiles.darea_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.darea_t.SIZE; if (count > MAX_MAP_AREAS) Com.Error(ERR_DROP, "Map has too many areas"); Com.DPrintf(" numareas=" + count + "\n"); numareas = count; if (debugloadmap) { Com.DPrintf("areas(numportals, firstportal)\n"); } for (i = 0; i < count; i++) { in = new qfiles.darea_t(ByteBuffer.wrap(cmod_base, i * qfiles.darea_t.SIZE + l.fileofs, qfiles.darea_t.SIZE)); out = map_areas[i]; out.numareaportals = in.numareaportals; out.firstareaportal = in.firstareaportal; out.floodvalid = 0; out.floodnum = 0; if (debugloadmap) { Com.DPrintf("| %6i| %6i|\n", new Vargs().add(out.numareaportals).add(out.firstareaportal)); } } } /* ================= CMod_LoadAreaPortals ================= */ public static void CMod_LoadAreaPortals(lump_t l) { Com.DPrintf("CMod_LoadAreaPortals...\n"); int i; qfiles.dareaportal_t out; qfiles.dareaportal_t in; int count; if ((l.filelen % qfiles.dareaportal_t.SIZE) != 0) Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size"); count = l.filelen / qfiles.dareaportal_t.SIZE; if (count > MAX_MAP_AREAS) Com.Error(ERR_DROP, "Map has too many areas"); numareaportals = count; Com.DPrintf(" numareaportals=" + count + "\n"); if (debugloadmap) { Com.DPrintf("areaportals(portalnum, otherarea)\n"); } for (i = 0; i < count; i++) { in = new qfiles.dareaportal_t( ByteBuffer.wrap(cmod_base, i * qfiles.dareaportal_t.SIZE + l.fileofs, qfiles.dareaportal_t.SIZE)); out = map_areaportals[i]; out.portalnum = in.portalnum; out.otherarea = in.otherarea; if (debugloadmap) { Com.DPrintf("|%6i|%6i|\n", new Vargs().add(out.portalnum).add(out.otherarea)); } } } /* ================= CMod_LoadVisibility ================= */ public static void CMod_LoadVisibility(lump_t l) { Com.DPrintf("CMod_LoadVisibility...\n"); int i; numvisibility = l.filelen; Com.DPrintf(" numvisibility=" + numvisibility + "\n"); if (l.filelen > MAX_MAP_VISIBILITY) Com.Error(ERR_DROP, "Map has too large visibility lump"); //was: memcpy(map_visibility, cmod_base + l.fileofs, l.filelen); System.arraycopy(cmod_base, l.fileofs, map_visibility, 0, l.filelen); ByteBuffer bb = ByteBuffer.wrap(map_visibility, 0, l.filelen); bb.order(ByteOrder.LITTLE_ENDIAN); map_vis = new qfiles.dvis_t(bb); } /* ================= CMod_LoadEntityString ================= */ public static void CMod_LoadEntityString(lump_t l) { Com.DPrintf("CMod_LoadEntityString...\n"); numentitychars = l.filelen; if (l.filelen > MAX_MAP_ENTSTRING) Com.Error(ERR_DROP, "Map has too large entity lump"); int x = 0; for (; x < l.filelen && cmod_base[x + l.fileofs] != 0; x++); map_entitystring = new String(cmod_base, l.fileofs, x).trim(); } /* ================== CM_InlineModel ================== */ // works fine public static cmodel_t InlineModel(String name) { int num; if (name == null || name.charAt(0) != '*') Com.Error(ERR_DROP, "CM_InlineModel: bad name"); num = atoi(name.substring(1)); if (num < 1 || num >= numcmodels) Com.Error(ERR_DROP, "CM_InlineModel: bad number"); return map_cmodels[num]; } public static int CM_NumClusters() { return numclusters; } public static int CM_NumInlineModels() { return numcmodels; } public static String CM_EntityString() { return map_entitystring; } public static int CM_LeafContents(int leafnum) { if (leafnum < 0 || leafnum >= numleafs) Com.Error(ERR_DROP, "CM_LeafContents: bad number"); return map_leafs[leafnum].contents; } public static int CM_LeafCluster(int leafnum) { if (leafnum < 0 || leafnum >= numleafs) Com.Error(ERR_DROP, "CM_LeafCluster: bad number"); return map_leafs[leafnum].cluster; } public static int CM_LeafArea(int leafnum) { if (leafnum < 0 || leafnum >= numleafs) Com.Error(ERR_DROP, "CM_LeafArea: bad number"); return map_leafs[leafnum].area; } //======================================================================= static cplane_t box_planes[]; static int box_headnode; static cbrush_t box_brush; static cleaf_t box_leaf; /* =================== CM_InitBoxHull Set up the planes and nodes so that the six floats of a bounding box can just be stored out and get a proper clipping hull structure. =================== */ public static void CM_InitBoxHull() { int i; int side; cnode_t c; cplane_t p; cbrushside_t s; box_headnode = numnodes; // noch platz f?r 6 brushes box_planes = new cplane_t[] { map_planes[numplanes], map_planes[numplanes + 1], map_planes[numplanes + 2], map_planes[numplanes + 3], map_planes[numplanes + 4], map_planes[numplanes + 5], map_planes[numplanes + 6], map_planes[numplanes + 7], map_planes[numplanes + 8], map_planes[numplanes + 9], map_planes[numplanes + 10], map_planes[numplanes + 11], map_planes[numplanes + 12] }; if (numnodes + 6 > MAX_MAP_NODES || numbrushes + 1 > MAX_MAP_BRUSHES || numleafbrushes + 1 > MAX_MAP_LEAFBRUSHES || numbrushsides + 6 > MAX_MAP_BRUSHSIDES || numplanes + 12 > MAX_MAP_PLANES) Com.Error(ERR_DROP, "Not enough room for box tree"); box_brush = map_brushes[numbrushes]; box_brush.numsides = 6; box_brush.firstbrushside = numbrushsides; box_brush.contents = CONTENTS_MONSTER; box_leaf = map_leafs[numleafs]; box_leaf.contents = CONTENTS_MONSTER; box_leaf.firstleafbrush = (short) numleafbrushes; box_leaf.numleafbrushes = 1; map_leafbrushes[numleafbrushes] = numbrushes; for (i = 0; i < 6; i++) { side = i & 1; // brush sides s = map_brushsides[numbrushsides + i]; s.plane = map_planes[(numplanes + i * 2 + side)]; s.surface = nullsurface; // nodes c = map_nodes[box_headnode + i]; c.plane = map_planes[(numplanes + i * 2)]; c.children[side] = -1 - emptyleaf; if (i != 5) c.children[side ^ 1] = box_headnode + i + 1; else c.children[side ^ 1] = -1 - numleafs; // planes p = box_planes[i * 2]; p.type = (byte) (i >> 1); p.signbits = 0; VectorClear(p.normal); p.normal[i >> 1] = 1; p = box_planes[i * 2 + 1]; p.type = (byte) (3 + (i >> 1)); p.signbits = 0; VectorClear(p.normal); p.normal[i >> 1] = -1; } } /* =================== CM_HeadnodeForBox To keep everything totally uniform, bounding boxes are turned into small BSP trees instead of being compared directly. =================== */ public static int HeadnodeForBox(float[] mins, float[] maxs) { box_planes[0].dist = maxs[0]; box_planes[1].dist = -maxs[0]; box_planes[2].dist = mins[0]; box_planes[3].dist = -mins[0]; box_planes[4].dist = maxs[1]; box_planes[5].dist = -maxs[1]; box_planes[6].dist = mins[1]; box_planes[7].dist = -mins[1]; box_planes[8].dist = maxs[2]; box_planes[9].dist = -maxs[2]; box_planes[10].dist = mins[2]; box_planes[11].dist = -mins[2]; return box_headnode; } /* ================== CM_PointLeafnum_r ================== */ public static int CM_PointLeafnum_r(float[] p, int num) { float d; cnode_t node; cplane_t plane; while (num >= 0) { node = map_nodes[num]; plane = node.plane; if (plane.type < 3) d = p[plane.type] - plane.dist; else d = DotProduct(plane.normal, p) - plane.dist; if (d < 0) num = node.children[1]; else num = node.children[0]; } c_pointcontents++; // optimize counter return -1 - num; } public static int CM_PointLeafnum(float[] p) { if (numplanes == 0) return 0; // sound may call this without map loaded return CM_PointLeafnum_r(p, 0); } /* ============= CM_BoxLeafnums Fills in a list of all the leafs touched ============= */ static int leaf_count, leaf_maxcount; static int leaf_list[]; static float leaf_mins[], leaf_maxs[]; static int leaf_topnode; public static void CM_BoxLeafnums_r(int nodenum) { cplane_t plane; cnode_t node; int s; while (true) { if (nodenum < 0) { if (leaf_count >= leaf_maxcount) { Com.DPrintf("CM_BoxLeafnums_r: overflow\n"); return; } leaf_list[leaf_count++] = -1 - nodenum; return; } node = map_nodes[nodenum]; plane = node.plane; s = Math3D.BoxOnPlaneSide(leaf_mins, leaf_maxs, plane); if (s == 1) nodenum = node.children[0]; else if (s == 2) nodenum = node.children[1]; else { // go down both if (leaf_topnode == -1) leaf_topnode = nodenum; CM_BoxLeafnums_r(node.children[0]); nodenum = node.children[1]; } } } public static int CM_BoxLeafnums_headnode(float[] mins, float[] maxs, int list[], int listsize, int headnode, intwrap topnode) { leaf_list = list; leaf_count = 0; leaf_maxcount = listsize; leaf_mins = mins; leaf_maxs = maxs; leaf_topnode = -1; CM_BoxLeafnums_r(headnode); if (topnode != null) topnode.i = leaf_topnode; return leaf_count; } public static int CM_BoxLeafnums(float[] mins, float[] maxs, int list[], int listsize, intwrap topnode) { return CM_BoxLeafnums_headnode(mins, maxs, list, listsize, map_cmodels[0].headnode, topnode); } public static class intwrap { public intwrap(int i) { this.i = i; } public int i; } /* ================== CM_PointContents ================== */ public static int PointContents(float[] p, int headnode) { int l; if (numnodes == 0) // map not loaded return 0; l = CM_PointLeafnum_r(p, headnode); return map_leafs[l].contents; } /* ================== CM_TransformedPointContents Handles offseting and rotation of the end points for moving and rotating entities ================== */ public static int TransformedPointContents(float[] p, int headnode, float[] origin, float[] angles) { float[] p_l = { 0, 0, 0 }; float[] temp = { 0, 0, 0 }; float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 }; int l; // subtract origin offset VectorSubtract(p, origin, p_l); // rotate start and end into the models frame of reference if (headnode != box_headnode && (angles[0] != 0 || angles[1] != 0 || angles[2] != 0)) { AngleVectors(angles, forward, right, up); VectorCopy(p_l, temp); p_l[0] = DotProduct(temp, forward); p_l[1] = -DotProduct(temp, right); p_l[2] = DotProduct(temp, up); } l = CM_PointLeafnum_r(p_l, headnode); return map_leafs[l].contents; } /* =============================================================================== BOX TRACING =============================================================================== */ // 1/32 epsilon to keep floating point happy private static final float DIST_EPSILON = 0.03125f; private static float[] trace_start = { 0, 0, 0 }, trace_end = { 0, 0, 0 }; private static float[] trace_mins = { 0, 0, 0 }, trace_maxs = { 0, 0, 0 }; private static float[] trace_extents = { 0, 0, 0 }; private static trace_t trace_trace = new trace_t(); private static int trace_contents; private static boolean trace_ispoint; // optimized case /* ================ CM_ClipBoxToBrush ================ */ public static void CM_ClipBoxToBrush(float[] mins, float[] maxs, float[] p1, float[] p2, trace_t trace, cbrush_t brush) { int i, j; cplane_t plane, clipplane; float dist; float enterfrac, leavefrac; float[] ofs = { 0, 0, 0 }; float d1, d2; boolean getout, startout; float f; cbrushside_t side, leadside; enterfrac = -1; leavefrac = 1; clipplane = null; if (brush.numsides == 0) return; c_brush_traces++; getout = false; startout = false; leadside = null; for (i = 0; i < brush.numsides; i++) { side = map_brushsides[brush.firstbrushside + i]; plane = side.plane; // FIXME: special case for axial if (!trace_ispoint) { // general box case // push the plane out apropriately for mins/maxs // FIXME: use signbits into 8 way lookup for each mins/maxs for (j = 0; j < 3; j++) { if (plane.normal[j] < 0) ofs[j] = maxs[j]; else ofs[j] = mins[j]; } dist = DotProduct(ofs, plane.normal); dist = plane.dist - dist; } else { // special point case dist = plane.dist; } d1 = DotProduct(p1, plane.normal) - dist; d2 = DotProduct(p2, plane.normal) - dist; if (d2 > 0) getout = true; // endpoint is not in solid if (d1 > 0) startout = true; // if completely in front of face, no intersection if (d1 > 0 && d2 >= d1) return; if (d1 <= 0 && d2 <= 0) continue; // crosses face if (d1 > d2) { // enter f = (d1 - DIST_EPSILON) / (d1 - d2); if (f > enterfrac) { enterfrac = f; clipplane = plane; leadside = side; } } else { // leave f = (d1 + DIST_EPSILON) / (d1 - d2); if (f < leavefrac) leavefrac = f; } } if (!startout) { // original point was inside brush trace.startsolid = true; if (!getout) trace.allsolid = true; return; } if (enterfrac < leavefrac) { if (enterfrac > -1 && enterfrac < trace.fraction) { if (enterfrac < 0) enterfrac = 0; trace.fraction = enterfrac; // copy trace.plane.set(clipplane); trace.surface = leadside.surface.c; trace.contents = brush.contents; } } } /* ================ CM_TestBoxInBrush ================ */ public static void CM_TestBoxInBrush(float[] mins, float[] maxs, float[] p1, trace_t trace, cbrush_t brush) { int i, j; cplane_t plane; float dist; float[] ofs = { 0, 0, 0 }; float d1; cbrushside_t side; if (brush.numsides == 0) return; for (i = 0; i < brush.numsides; i++) { side = map_brushsides[brush.firstbrushside + i]; plane = side.plane; // FIXME: special case for axial // general box case // push the plane out apropriately for mins/maxs // FIXME: use signbits into 8 way lookup for each mins/maxs for (j = 0; j < 3; j++) { if (plane.normal[j] < 0) ofs[j] = maxs[j]; else ofs[j] = mins[j]; } dist = DotProduct(ofs, plane.normal); dist = plane.dist - dist; d1 = DotProduct(p1, plane.normal) - dist; // if completely in front of face, no intersection if (d1 > 0) return; } // inside this brush trace.startsolid = trace.allsolid = true; trace.fraction = 0; trace.contents = brush.contents; } /* ================ CM_TraceToLeaf ================ */ public static void CM_TraceToLeaf(int leafnum) { int k; int brushnum; cleaf_t leaf; cbrush_t b; leaf = map_leafs[leafnum]; if (0 == (leaf.contents & trace_contents)) return; // trace line against all brushes in the leaf for (k = 0; k < leaf.numleafbrushes; k++) { brushnum = map_leafbrushes[leaf.firstleafbrush + k]; b = map_brushes[brushnum]; if (b.checkcount == checkcount) continue; // already checked this brush in another leaf b.checkcount = checkcount; if (0 == (b.contents & trace_contents)) continue; CM_ClipBoxToBrush(trace_mins, trace_maxs, trace_start, trace_end, trace_trace, b); if (0 == trace_trace.fraction) return; } } /* ================ CM_TestInLeaf ================ */ public static void CM_TestInLeaf(int leafnum) { int k; int brushnum; cleaf_t leaf; cbrush_t b; leaf = map_leafs[leafnum]; if (0 == (leaf.contents & trace_contents)) return; // trace line against all brushes in the leaf for (k = 0; k < leaf.numleafbrushes; k++) { brushnum = map_leafbrushes[leaf.firstleafbrush + k]; b = map_brushes[brushnum]; if (b.checkcount == checkcount) continue; // already checked this brush in another leaf b.checkcount = checkcount; if (0 == (b.contents & trace_contents)) continue; CM_TestBoxInBrush(trace_mins, trace_maxs, trace_start, trace_trace, b); if (0 == trace_trace.fraction) return; } } /* ================== CM_RecursiveHullCheck ================== */ public static void CM_RecursiveHullCheck(int num, float p1f, float p2f, float[] p1, float[] p2) { cnode_t node; cplane_t plane; float t1, t2, offset; float frac, frac2; float idist; int i; float[] mid = { 0, 0, 0 }; int side; float midf; if (trace_trace.fraction <= p1f) return; // already hit something nearer // if < 0, we are in a leaf node if (num < 0) { CM_TraceToLeaf(-1 - num); return; } // // find the point distances to the seperating plane // and the offset for the size of the box // node = map_nodes[num]; plane = node.plane; if (plane.type < 3) { t1 = p1[plane.type] - plane.dist; t2 = p2[plane.type] - plane.dist; offset = trace_extents[plane.type]; } else { t1 = DotProduct(plane.normal, p1) - plane.dist; t2 = DotProduct(plane.normal, p2) - plane.dist; if (trace_ispoint) offset = 0; else offset = Math.abs(trace_extents[0] * plane.normal[0]) + Math.abs(trace_extents[1] * plane.normal[1]) + Math.abs(trace_extents[2] * plane.normal[2]); } // see which sides we need to consider if (t1 >= offset && t2 >= offset) { CM_RecursiveHullCheck(node.children[0], p1f, p2f, p1, p2); return; } if (t1 < -offset && t2 < -offset) { CM_RecursiveHullCheck(node.children[1], p1f, p2f, p1, p2); return; } // put the crosspoint DIST_EPSILON pixels on the near side if (t1 < t2) { idist = 1.0f / (t1 - t2); side = 1; frac2 = (t1 + offset + DIST_EPSILON) * idist; frac = (t1 - offset + DIST_EPSILON) * idist; } else if (t1 > t2) { idist = 1.0f / (t1 - t2); side = 0; frac2 = (t1 - offset - DIST_EPSILON) * idist; frac = (t1 + offset + DIST_EPSILON) * idist; } else { side = 0; frac = 1; frac2 = 0; } // move up to the node if (frac < 0) frac = 0; if (frac > 1) frac = 1; midf = p1f + (p2f - p1f) * frac; for (i = 0; i < 3; i++) mid[i] = p1[i] + frac * (p2[i] - p1[i]); CM_RecursiveHullCheck(node.children[side], p1f, midf, p1, mid); // go past the node if (frac2 < 0) frac2 = 0; if (frac2 > 1) frac2 = 1; midf = p1f + (p2f - p1f) * frac2; for (i = 0; i < 3; i++) mid[i] = p1[i] + frac2 * (p2[i] - p1[i]); CM_RecursiveHullCheck(node.children[side ^ 1], midf, p2f, mid, p2); } //====================================================================== /* ================== CM_BoxTrace ================== */ public static trace_t BoxTrace(float[] start, float[] end, float[] mins, float[] maxs, int headnode, int brushmask) { // for multi-check avoidance checkcount++; // for statistics, may be zeroed c_traces++; // fill in a default trace //was: memset(& trace_trace, 0, sizeof(trace_trace)); trace_trace = new trace_t(); trace_trace.fraction = 1; trace_trace.surface = nullsurface.c; if (numnodes == 0) // map not loaded { Com.DPrintf("dummy trace zurueck, da map not loaded!\n"); return trace_trace; } trace_contents = brushmask; VectorCopy(start, trace_start); VectorCopy(end, trace_end); VectorCopy(mins, trace_mins); VectorCopy(maxs, trace_maxs); // // check for position test special case // if (start[0] == end[0] && start[1] == end[1] && start[2] == end[2]) { int leafs[] = new int[1024]; int i, numleafs; float[] c1 = { 0, 0, 0 }, c2 = { 0, 0, 0 }; int topnode = 0; VectorAdd(start, mins, c1); VectorAdd(start, maxs, c2); for (i = 0; i < 3; i++) { c1[i] -= 1; c2[i] += 1; } intwrap tn = new intwrap(topnode); numleafs = CM_BoxLeafnums_headnode(c1, c2, leafs, 1024, headnode, tn); topnode = tn.i; for (i = 0; i < numleafs; i++) { CM_TestInLeaf(leafs[i]); if (trace_trace.allsolid) break; } VectorCopy(start, trace_trace.endpos); return trace_trace; } // // check for point special case // if (mins[0] == 0 && mins[1] == 0 && mins[2] == 0 && maxs[0] == 0 && maxs[1] == 0 && maxs[2] == 0) { trace_ispoint = true; VectorClear(trace_extents); } else { trace_ispoint = false; trace_extents[0] = -mins[0] > maxs[0] ? -mins[0] : maxs[0]; trace_extents[1] = -mins[1] > maxs[1] ? -mins[1] : maxs[1]; trace_extents[2] = -mins[2] > maxs[2] ? -mins[2] : maxs[2]; } // // general sweeping through world // CM_RecursiveHullCheck(headnode, 0, 1, start, end); if (trace_trace.fraction == 1) { VectorCopy(end, trace_trace.endpos); } else { for (int i = 0; i < 3; i++) trace_trace.endpos[i] = start[i] + trace_trace.fraction * (end[i] - start[i]); } return trace_trace; } /* ================== CM_TransformedBoxTrace Handles offseting and rotation of the end points for moving and rotating entities ================== */ public static trace_t TransformedBoxTrace( float[] start, float[] end, float[] mins, float[] maxs, int headnode, int brushmask, float[] origin, float[] angles) { trace_t trace; float[] start_l = { 0, 0, 0 }, end_l = { 0, 0, 0 }; float[] a = { 0, 0, 0 }; float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 }; float[] temp = { 0, 0, 0 }; boolean rotated; // subtract origin offset VectorSubtract(start, origin, start_l); VectorSubtract(end, origin, end_l); // rotate start and end into the models frame of reference if (headnode != box_headnode && (angles[0] != 0 || angles[1] != 0 || angles[2] != 0)) rotated = true; else rotated = false; if (rotated) { AngleVectors(angles, forward, right, up); VectorCopy(start_l, temp); start_l[0] = DotProduct(temp, forward); start_l[1] = -DotProduct(temp, right); start_l[2] = DotProduct(temp, up); VectorCopy(end_l, temp); end_l[0] = DotProduct(temp, forward); end_l[1] = -DotProduct(temp, right); end_l[2] = DotProduct(temp, up); } // sweep the box through the model trace = BoxTrace(start_l, end_l, mins, maxs, headnode, brushmask); if (rotated && trace.fraction != 1.0) { // FIXME: figure out how to do this with existing angles VectorNegate(angles, a); AngleVectors(a, forward, right, up); VectorCopy(trace.plane.normal, temp); trace.plane.normal[0] = DotProduct(temp, forward); trace.plane.normal[1] = -DotProduct(temp, right); trace.plane.normal[2] = DotProduct(temp, up); } trace.endpos[0] = start[0] + trace.fraction * (end[0] - start[0]); trace.endpos[1] = start[1] + trace.fraction * (end[1] - start[1]); trace.endpos[2] = start[2] + trace.fraction * (end[2] - start[2]); return trace; } /* =============================================================================== PVS / PHS =============================================================================== */ /* =================== CM_DecompressVis =================== */ public static void CM_DecompressVis(byte in[], int offset, byte out[]) { int c; int row; row = (numclusters + 7) >> 3; int outp = 0; int inp = offset; if (in == null || numvisibility == 0) { // no vis info, so make all visible while (row != 0) { out[outp++] = (byte) 0xFF; row--; } return; } do { if (in[inp] != 0) { out[outp++] = in[inp++]; continue; } c = in[inp + 1] & 0xFF; inp += 2; if (outp + c > row) { c = row - (outp); Com.DPrintf("warning: Vis decompression overrun\n"); } while (c != 0) { out[outp++] = 0; c--; } } while (outp < row); } public static byte pvsrow[] = new byte[MAX_MAP_LEAFS / 8]; public static byte phsrow[] = new byte[MAX_MAP_LEAFS / 8]; public static byte[] CM_ClusterPVS(int cluster) { if (cluster == -1) Lib.memset(pvsrow, (byte) 0, (numclusters + 7) >> 3); else CM_DecompressVis(map_visibility, map_vis.bitofs[cluster][DVIS_PVS], pvsrow); return pvsrow; } public static byte[] CM_ClusterPHS(int cluster) { if (cluster == -1) Lib.memset(phsrow, (byte) 0, (numclusters + 7) >> 3); else CM_DecompressVis(map_visibility, map_vis.bitofs[cluster][Defines.DVIS_PHS], phsrow); return phsrow; } /* =============================================================================== AREAPORTALS =============================================================================== */ public static void FloodArea_r(carea_t area, int floodnum) { Com.DPrintf("FloodArea_r(" + floodnum + ")...\n"); int i; qfiles.dareaportal_t p; if (area.floodvalid == floodvalid) { if (area.floodnum == floodnum) return; Com.Error(ERR_DROP, "FloodArea_r: reflooded"); } area.floodnum = floodnum; area.floodvalid = floodvalid; for (i = 0; i < area.numareaportals; i++) { p = map_areaportals[area.firstareaportal + i]; if (portalopen[p.portalnum]) FloodArea_r(map_areas[p.otherarea], floodnum); } } /* ==================== FloodAreaConnections ==================== */ public static void FloodAreaConnections() { Com.DPrintf("FloodAreaConnections...\n"); int i; carea_t area; int floodnum; // all current floods are now invalid floodvalid++; floodnum = 0; // area 0 is not used for (i = 1; i < numareas; i++) { area = map_areas[i]; if (area.floodvalid == floodvalid) continue; // already flooded into floodnum++; FloodArea_r(area, floodnum); } } /* ================= CM_SetAreaPortalState ================= */ public static void CM_SetAreaPortalState(int portalnum, boolean open) { if (portalnum > numareaportals) Com.Error(ERR_DROP, "areaportal > numareaportals"); portalopen[portalnum] = open; FloodAreaConnections(); } /* ================= CM_AreasConnected ================= */ public static boolean CM_AreasConnected(int area1, int area2) { if (map_noareas.value != 0) return true; if (area1 > numareas || area2 > numareas) Com.Error(ERR_DROP, "area > numareas"); if (map_areas[area1].floodnum == map_areas[area2].floodnum) return true; return false; } /* ================= CM_WriteAreaBits Writes a length byte followed by a bit vector of all the areas that area in the same flood as the area parameter This is used by the client refreshes to cull visibility ================= */ public static int CM_WriteAreaBits(byte buffer[], int area) { int i; int floodnum; int bytes; bytes = (numareas + 7) >> 3; if (map_noareas.value != 0) { // for debugging, send everything Lib.memset(buffer, 255, bytes); } else { Lib.memset(buffer, 0, bytes); floodnum = map_areas[area].floodnum; for (i = 0; i < numareas; i++) { if (map_areas[i].floodnum == floodnum || area == 0) buffer[i >> 3] |= 1 << (i & 7); } } return bytes; } /* =================== CM_WritePortalState Writes the portal state to a savegame file =================== */ public static void CM_WritePortalState(RandomAccessFile os) { //was: fwrite(portalopen, sizeof(portalopen), 1, f); try { for (int n = 0; n < portalopen.length; n++) if (portalopen[n]) os.writeInt(1); else os.writeInt(0); } catch (Exception e) { Com.Printf("ERROR:" + e); e.printStackTrace(); } } /* =================== CM_ReadPortalState Reads the portal state from a savegame file and recalculates the area connections =================== */ public static void CM_ReadPortalState(RandomAccessFile f) { //was: FS_Read(portalopen, sizeof(portalopen), f); int len = portalopen.length * 4; byte buf[] = new byte[len]; try { FS.Read(buf, len, f); } catch (FileNotFoundException e) { Com.Printf("ERROR:" + e); } ByteBuffer bb = ByteBuffer.wrap(buf); IntBuffer ib = bb.asIntBuffer(); //TODO: i assume upward counting (rst) for (int n = 0; n < portalopen.length; n++) portalopen[n] = ib.get() != 0; FloodAreaConnections(); } /* ============= CM_HeadnodeVisible Returns true if any leaf under headnode has a cluster that is potentially visible ============= */ public static boolean CM_HeadnodeVisible(int nodenum, byte visbits[]) { int leafnum; int cluster; cnode_t node; if (nodenum < 0) { leafnum = -1 - nodenum; cluster = map_leafs[leafnum].cluster; if (cluster == -1) return false; if (0 != (visbits[cluster >>> 3] & (1 << (cluster & 7)))) return true; return false; } node = map_nodes[nodenum]; if (CM_HeadnodeVisible(node.children[0], visbits)) return true; return CM_HeadnodeVisible(node.children[1], visbits); } }