warp.java

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

	private final float[] av = {0, 0, 0};
	/**
	 * DrawSkyPolygon
	 * @param nump
	 * @param vecs
	 */
	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;
		}
	}

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

	/**
	 * ClipSkyPolygon
	 * @param nump
	 * @param vecs
	 * @param stage
	 */
	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);
	}

	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()
	{
		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;
		}
	}
	
	// stack variable
	private final float[] v1 = {0, 0, 0};
	private final float[] b = {0, 0, 0};
	/**
	 * MakeSkyVec
	 * @param s
	 * @param t
	 * @param axis
	 */
	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;
		gl.glTexCoord2f (s, t);
		gl.glVertex3f(v1[0], v1[1], v1[2]);
	}

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

	/**
	 * R_DrawSkyBox
	 */
	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(GL11.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 ();
	}

	// 3dstudio environment map names
	String[] suf = {"rt", "bk", "lf", "ft", "up", "dn"};
	
	/**
	 * R_SetSky
	 * @param name
	 * @param rotate
	 * @param axis
	 */
	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, 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;
			}
		}
	}
}