cm.java

JAKE2用ＪＡＶＡ写的queck2的３Ｄ游戏开发引擎

            if (debugloadmap) {
                Com
                        .DPrintf("| %6i| %6i| %8X|\n", new Vargs().add(
                                out.firstbrushside).add(out.numsides).add(
                                out.contents));
            }
        }
    }

    /** Loads leafs.   */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");

        count = l.filelen / qfiles.dleaf_t.SIZE;

        if (count < 1)
            Com.Error(Defines.ERR_DROP, "Map with no leafs");

        // need to save space for box planes
        if (count > Defines.MAX_MAP_PLANES)
            Com.Error(Defines.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 != Defines.CONTENTS_SOLID)
            Com.Error(Defines.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(Defines.ERR_DROP, "Map does not have an empty leaf");
    }

    /** Loads planes. */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");

        count = l.filelen / qfiles.dplane_t.SIZE;

        if (count < 1)
            Com.Error(Defines.ERR_DROP, "Map with no planes");

        // need to save space for box planes
        if (count > Defines.MAX_MAP_PLANES)
            Com.Error(Defines.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));
            }
        }
    }

    /** Loads leaf brushes. */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");

        count = l.filelen / 2;

        Com.DPrintf(" numbrushes=" + count + "\n");

        if (count < 1)
            Com.Error(Defines.ERR_DROP, "Map with no planes");

        // need to save space for box planes
        if (count > Defines.MAX_MAP_LEAFBRUSHES)
            Com.Error(Defines.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]));
            }
        }
    }

    /** Loads brush sides. */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");
        count = l.filelen / qfiles.dbrushside_t.SIZE;

        // need to save space for box planes
        if (count > Defines.MAX_MAP_BRUSHSIDES)
            Com.Error(Defines.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(Defines.ERR_DROP, "Bad brushside texinfo");

            // java specific handling of -1
            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));
            }
        }
    }

    /** Loads areas. */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");

        count = l.filelen / qfiles.darea_t.SIZE;

        if (count > Defines.MAX_MAP_AREAS)
            Com.Error(Defines.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));
            }
        }
    }

    /** Loads area portals. */
    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(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size");
        count = l.filelen / qfiles.dareaportal_t.SIZE;

        if (count > Defines.MAX_MAP_AREAS)
            Com.Error(Defines.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));
            }
        }
    }

    /** Loads visibility data. */
    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 > Defines.MAX_MAP_VISIBILITY)
            Com.Error(Defines.ERR_DROP, "Map has too large visibility lump");

        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);

    }

    /** Loads entity strings. */
    public static void CMod_LoadEntityString(lump_t l) {
        Com.DPrintf("CMod_LoadEntityString()\n");

        numentitychars = l.filelen;

        if (l.filelen > Defines.MAX_MAP_ENTSTRING)
            Com.Error(Defines.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();
        Com.dprintln("entitystring=" + map_entitystring.length() + 
                " bytes, [" + map_entitystring.substring(0, Math.min (
                        map_entitystring.length(), 15)) + "...]" );
    }

    /** Returns the model with a given id "*" + <number> */
    public static cmodel_t InlineModel(String name) {
        int num;

        if (name == null || name.charAt(0) != '*')
            Com.Error(Defines.ERR_DROP, "CM_InlineModel: bad name");

        num = Lib.atoi(name.substring(1));

        if (num < 1 || num >= numcmodels)
            Com.Error(Defines.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(Defines.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(Defines.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(Defines.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;

    /** 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; //rst: still room for 6 brushes left?

        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 > Defines.MAX_MAP_NODES
                || numbrushes + 1 > Defines.MAX_MAP_BRUSHES
                || numleafbrushes + 1 > Defines.MAX_MAP_LEAFBRUSHES
                || numbrushsides + 6 > Defines.MAX_MAP_BRUSHSIDES
                || numplanes + 12 > Defines.MAX_MAP_PLANES)
            Com.Error(Defines.ERR_DROP, "Not enough room for box tree");

        box_brush = map_brushes[numbrushes];
        box_brush.numsides = 6;
        box_brush.firstbrushside = numbrushsides;
        box_brush.contents = Defines.CONTENTS_MONSTER;

        box_leaf = map_leafs[numleafs];
        box_leaf.contents = Defines.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;
            Math3D.VectorClear(p.normal);
            p.normal[i >> 1] = 1;