warp.java

Jake2是一个Java 3D游戏引擎.

    int[][] vec_to_st = { { -2, 3, 1 }, { 2, 3, -1 },

    { 1, 3, 2 }, { -1, 3, -2 },

    { -2, -1, 3 }, { -2, 1, -3 }

    };

    float[][] skymins = new float[2][6];

    float[][] skymaxs = new float[2][6];

    float sky_min, sky_max;

    void DrawSkyPolygon(int nump, float[][] vecs) {
        int i, j;
        float[] v = { 0, 0, 0 };
        float[] av = { 0, 0, 0 };
        float s, t, dv;
        int axis;
        float[] vp;

        c_sky++;
        // decide which face it maps to
        Math3D.VectorCopy(Globals.vec3_origin, v);
        for (i = 0; i < nump; i++) {
            Math3D.VectorAdd(vecs[i], v, v);
        }
        av[0] = Math.abs(v[0]);
        av[1] = Math.abs(v[1]);
        av[2] = Math.abs(v[2]);
        if (av[0] > av[1] && av[0] > av[2]) {
            if (v[0] < 0)
                axis = 1;
            else
                axis = 0;
        } else if (av[1] > av[2] && av[1] > av[0]) {
            if (v[1] < 0)
                axis = 3;
            else
                axis = 2;
        } else {
            if (v[2] < 0)
                axis = 5;
            else
                axis = 4;
        }

        // project new texture coords
        for (i = 0; i < nump; i++) {
            j = vec_to_st[axis][2];
            if (j > 0)
                dv = vecs[i][j - 1];
            else
                dv = -vecs[i][-j - 1];
            if (dv < 0.001f)
                continue; // don't divide by zero
            j = vec_to_st[axis][0];
            if (j < 0)
                s = -vecs[i][-j - 1] / dv;
            else
                s = vecs[i][j - 1] / dv;
            j = vec_to_st[axis][1];
            if (j < 0)
                t = -vecs[i][-j - 1] / dv;
            else
                t = vecs[i][j - 1] / dv;

            if (s < skymins[0][axis])
                skymins[0][axis] = s;
            if (t < skymins[1][axis])
                skymins[1][axis] = t;
            if (s > skymaxs[0][axis])
                skymaxs[0][axis] = s;
            if (t > skymaxs[1][axis])
                skymaxs[1][axis] = t;
        }
    }

    static final float ON_EPSILON = 0.1f; // point on plane side epsilon

    static final int MAX_CLIP_VERTS = 64;

    static final int SIDE_BACK = 1;

    static final int SIDE_FRONT = 0;

    static final int SIDE_ON = 2;

    float[] dists = new float[MAX_CLIP_VERTS];

    int[] sides = new int[MAX_CLIP_VERTS];

    float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3];

    void ClipSkyPolygon(int nump, float[][] vecs, int stage) {
        float[] norm;
        float[] v;
        boolean front, back;
        float d, e;
        int[] newc = { 0, 0 };
        int i, j;

        if (nump > MAX_CLIP_VERTS - 2)
            Com.Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS");
        if (stage == 6) { // fully clipped, so draw it
            DrawSkyPolygon(nump, vecs);
            return;
        }

        front = back = false;
        norm = skyclip[stage];
        for (i = 0; i < nump; i++) {
            d = Math3D.DotProduct(vecs[i], norm);
            if (d > ON_EPSILON) {
                front = true;
                sides[i] = SIDE_FRONT;
            } else if (d < -ON_EPSILON) {
                back = true;
                sides[i] = SIDE_BACK;
            } else
                sides[i] = SIDE_ON;
            dists[i] = d;
        }

        if (!front || !back) { // not clipped
            ClipSkyPolygon(nump, vecs, stage + 1);
            return;
        }

        // clip it
        sides[i] = sides[0];
        dists[i] = dists[0];
        Math3D.VectorCopy(vecs[0], vecs[i]);
        newc[0] = newc[1] = 0;

        for (i = 0; i < nump; i++) {
            v = vecs[i];
            switch (sides[i]) {
            case SIDE_FRONT:
                Math3D.VectorCopy(v, newv[stage][0][newc[0]]);
                newc[0]++;
                break;
            case SIDE_BACK:
                Math3D.VectorCopy(v, newv[stage][1][newc[1]]);
                newc[1]++;
                break;
            case SIDE_ON:
                Math3D.VectorCopy(v, newv[stage][0][newc[0]]);
                newc[0]++;
                Math3D.VectorCopy(v, newv[stage][1][newc[1]]);
                newc[1]++;
                break;
            }

            if (sides[i] == SIDE_ON || sides[i + 1] == SIDE_ON
                    || sides[i + 1] == sides[i])
                continue;

            d = dists[i] / (dists[i] - dists[i + 1]);
            for (j = 0; j < 3; j++) {
                e = v[j] + d * (vecs[i + 1][j] - v[j]);
                newv[stage][0][newc[0]][j] = e;
                newv[stage][1][newc[1]][j] = e;
            }
            newc[0]++;
            newc[1]++;
        }

        // continue
        ClipSkyPolygon(newc[0], newv[stage][0], stage + 1);
        ClipSkyPolygon(newc[1], newv[stage][1], stage + 1);
    }

    float[][] verts = new float[MAX_CLIP_VERTS][3];

    /*
     * R_AddSkySurface
     */
    void R_AddSkySurface(msurface_t fa) {
        // 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 ==============
     */
    void R_ClearSkyBox() {
        int i;

        for (i = 0; i < 6; i++) {
            skymins[0][i] = skymins[1][i] = 9999;
            skymaxs[0][i] = skymaxs[1][i] = -9999;
        }
    }

    void MakeSkyVec(float s, float t, int axis) {
        float[] v = { 0, 0, 0 };
        float[] b = { 0, 0, 0 };
        int j, k;

        b[0] = s * 2300;
        b[1] = t * 2300;
        b[2] = 2300;

        for (j = 0; j < 3; j++) {
            k = st_to_vec[axis][j];
            if (k < 0)
                v[j] = -b[-k - 1];
            else
                v[j] = b[k - 1];
        }

        // avoid bilerp seam
        s = (s + 1) * 0.5f;
        t = (t + 1) * 0.5f;

        if (s < sky_min)
            s = sky_min;
        else if (s > sky_max)
            s = sky_max;
        if (t < sky_min)
            t = sky_min;
        else if (t > sky_max)
            t = sky_max;

        t = 1.0f - t;
        gl.glTexCoord2f(s, t);
        gl.glVertex3f(v[0], v[1], v[2]);
    }

    /*
     * ============== R_DrawSkyBox ==============
     */
    int[] skytexorder = { 0, 2, 1, 3, 4, 5 };

    void R_DrawSkyBox() {
        int i;

        if (skyrotate != 0) { // check for no sky at all
            for (i = 0; i < 6; i++)
                if (skymins[0][i] < skymaxs[0][i]
                        && skymins[1][i] < skymaxs[1][i])
                    break;
            if (i == 6)
                return; // nothing visible
        }

        gl.glPushMatrix();
        gl.glTranslatef(r_origin[0], r_origin[1], r_origin[2]);
        gl.glRotatef(r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1],
                skyaxis[2]);

        for (i = 0; i < 6; i++) {
            if (skyrotate != 0) { // hack, forces full sky to draw when rotating
                skymins[0][i] = -1;
                skymins[1][i] = -1;
                skymaxs[0][i] = 1;
                skymaxs[1][i] = 1;
            }

            if (skymins[0][i] >= skymaxs[0][i]
                    || skymins[1][i] >= skymaxs[1][i])
                continue;

            GL_Bind(sky_images[skytexorder[i]].texnum);

            gl.glBegin(GL.GL_QUADS);
            MakeSkyVec(skymins[0][i], skymins[1][i], i);
            MakeSkyVec(skymins[0][i], skymaxs[1][i], i);
            MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i);
            MakeSkyVec(skymaxs[0][i], skymins[1][i], i);
            gl.glEnd();
        }
        gl.glPopMatrix();
    }

    /*
     * ============ R_SetSky ============
     */
    // 3dstudio environment map names
    String[] suf = { "rt", "bk", "lf", "ft", "up", "dn" };

    protected void R_SetSky(String name, float rotate, float[] axis) {
        assert (axis.length == 3) : "vec3_t bug";
        int i;
        String pathname;

        //		strncpy (skyname, name, sizeof(skyname)-1);
        skyname = name;

        skyrotate = rotate;
        Math3D.VectorCopy(axis, skyaxis);

        for (i = 0; i < 6; i++) {
            // chop down rotating skies for less memory
            if (gl_skymip.value != 0 || skyrotate != 0)
                gl_picmip.value++;

            if (qglColorTableEXT && gl_ext_palettedtexture.value != 0) {
                //	Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx",
                // skyname, suf[i]);
                pathname = "env/" + skyname + suf[i] + ".pcx";
            } else {
                // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.tga",
                // skyname, suf[i]);
                pathname = "env/" + skyname + suf[i] + ".tga";
            }

            sky_images[i] = GL_FindImage(pathname, it_sky);

            if (sky_images[i] == null)
                sky_images[i] = r_notexture;

            if (gl_skymip.value != 0 || skyrotate != 0) { // take less memory
                gl_picmip.value--;
                sky_min = 1.0f / 256;
                sky_max = 255.0f / 256;
            } else {
                sky_min = 1.0f / 512;
                sky_max = 511.0f / 512;
            }
        }
    }

}