[Jake2-commits] jake2/src/jake2/render/fast Misc.java, 1.1, 1.2 Warp.java, 1.1, 1.2 Anorms.java, 1.1, 1.2 Light.java, 1.1, 1.2 Polygon.java, 1.1, 1.2 Model.java, 1.1, 1.2 Mesh.java, 1.1, 1.2 Surf.java, 1.1, 1.2 Main.java, 1.1, 1.2 Draw.java, 1.1, 1.2 Image.java, 1.1, 1.2

[Carsten W. <ca...@us...>]

Update of /cvsroot/jake2/jake2/src/jake2/render/fast
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv15997/src/jake2/render/fast

Added Files:
	Misc.java Warp.java Anorms.java Light.java Polygon.java 
	Model.java Mesh.java Surf.java Main.java Draw.java Image.java 
Log Message:
merge render-refactoring branch into the HEAD

--- NEW FILE: Image.java ---
/*
 * Image.java
 * Copyright (C) 2003
 *
 * $Id: Image.java,v 1.2 2006/11/21 00:50:46 cawe 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.
[...1638 lines suppressed...]
		image_t image;
		
		for (int i=0; i < numgltextures ; i++)
		{
			image = gltextures[i];
			
			if (image.registration_sequence == 0)
	   			continue; // free image_t slot
            
			// free it
			texnumBuffer.clear();
			texnumBuffer.put(0,image.texnum);
			gl.glDeleteTextures(texnumBuffer);
            
            imageCache.remove(image.name);
	  		image.clear();
		}
	}

}

--- NEW FILE: Surf.java ---
/*
 * Surf.java
 * Copyright (C) 2003
 *
 * $Id: Surf.java,v 1.2 2006/11/21 00:50:46 cawe 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.
[...1294 lines suppressed...]
//		IntBuffer pix = ByteBuffer.wrap(buf).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();
//		
//		int[] pixel = new int[w * h];
//		
//		pix.get(pixel);
//		
//		BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
//		image.setRGB(0,  0, w, h, pixel, 0, w);
//		AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(scale, scale), AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
//		BufferedImage tmp = op.filter(image, null);
//		
//		if (frame == null) {
//			frame = new ImageFrame(null);
//			frame.show();
//		} 
//		frame.showImage(tmp);
//		
//	}

}

--- NEW FILE: Light.java ---
/*
 * Light.java
 * Copyright (C) 2003
 *
 * $Id: Light.java,v 1.2 2006/11/21 00:50:46 cawe 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.fast;

import jake2.Defines;
import jake2.Globals;
import jake2.client.dlight_t;
import jake2.game.cplane_t;
import jake2.qcommon.Com;
import jake2.render.*;
import jake2.util.Math3D;
import jake2.util.Vec3Cache;

import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.Arrays;

/**
 * Light
 *  
 * @author cwei
 */
public abstract class Light extends Warp {
	// r_light.c

	int r_dlightframecount;

	static final int DLIGHT_CUTOFF = 64;

	/*
	=============================================================================

	DYNAMIC LIGHTS BLEND RENDERING

	=============================================================================
	*/

	// stack variable
	private final float[] v = {0, 0, 0};
	/**
	 * R_RenderDlight
	 */
	void R_RenderDlight(dlight_t light)
	{
		float rad = light.intensity * 0.35f;

		Math3D.VectorSubtract (light.origin, r_origin, v);

		gl.glBegin (GL_TRIANGLE_FAN);
		gl.glColor3f (light.color[0]*0.2f, light.color[1]*0.2f, light.color[2]*0.2f);
		int i;
		for (i=0 ; i<3 ; i++)
			v[i] = light.origin[i] - vpn[i]*rad;
		
		gl.glVertex3f(v[0], v[1], v[2]);
		gl.glColor3f (0,0,0);

		int j;
		float a;
		for (i=16 ; i>=0 ; i--)
		{
			a = (float)(i/16.0f * Math.PI*2);
			for (j=0 ; j<3 ; j++)
				v[j] = (float)(light.origin[j] + vright[j]*Math.cos(a)*rad
					+ vup[j]*Math.sin(a)*rad);
			gl.glVertex3f(v[0], v[1], v[2]);
		}
		gl.glEnd ();
	}

	/**
	 * R_RenderDlights
	 */
	void R_RenderDlights()
	{
		if (gl_flashblend.value == 0)
			return;

		r_dlightframecount = r_framecount + 1;	// because the count hasn't
												//  advanced yet for this frame
		gl.glDepthMask(false);
		gl.glDisable(GL_TEXTURE_2D);
		gl.glShadeModel (GL_SMOOTH);
		gl.glEnable (GL_BLEND);
		gl.glBlendFunc (GL_ONE, GL_ONE);

		for (int i=0 ; i<r_newrefdef.num_dlights ; i++)
		{
			R_RenderDlight(r_newrefdef.dlights[i]);
		}

		gl.glColor3f (1,1,1);
		gl.glDisable(GL_BLEND);
		gl.glEnable(GL_TEXTURE_2D);
		gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		gl.glDepthMask(true);
	}


	/*
	=============================================================================

	DYNAMIC LIGHTS

	=============================================================================
	*/

	/**
	 * R_MarkLights
	 */
	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_PushDlights
	 */
	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] );
		}
	}

	/*
	=============================================================================

	LIGHT SAMPLING

	=============================================================================
	*/

	float[] pointcolor = {0, 0, 0}; // vec3_t
	cplane_t lightplane; // used as shadow plane
	float[] lightspot = {0, 0, 0}; // vec3_t

	/**
	 * RecursiveLightPoint
	 * @param node
	 * @param start
	 * @param end
	 * @return
	 */
	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;
	}

	// stack variable
	private final float[] end = {0, 0, 0};
	/**
	 * R_LightPoint
	 */
	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);
	}

//	  ===================================================================

	float[] s_blocklights = new float[34 * 34 * 3];
	
// TODO sync with jogl renderer. hoz
	private final float[] impact = {0, 0, 0};
	/**
	 * R_AddDynamicLights
	 */
	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];
					}
				}
			}
		}
	}

	/**
	 * R_SetCacheState
	 */
	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;
		}
	}
	
	private Throwable gotoStore = new Throwable();

//	TODO sync with jogl renderer. hoz
	/**
	 * R_BuildLightMap
	 * 
	 * Combine and scale multiple lightmaps into the floating format in blocklights
	 */
	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) {
                int maps;

                for (i = 0; i < size * 3; i++)
                    s_blocklights[i] = 255;

                // TODO useless? hoz
                //				for (maps = 0 ; maps < Defines.MAXLIGHTMAPS &&
                // surf.styles[maps] != (byte)255; maps++)
                //				{
                //					style = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF];
                //				}

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

                //			memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size *
                // 3 );

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

}
--- NEW FILE: Mesh.java ---
/*
 * Mesh.java
 * Copyright (C) 2003
 *
 * $Id: Mesh.java,v 1.2 2006/11/21 00:50:46 cawe 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.fast;

import jake2.Defines;
import jake2.client.VID;
import jake2.client.entity_t;
import jake2.qcommon.qfiles;
import jake2.render.image_t;
import jake2.util.Lib;
import jake2.util.Math3D;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;

/**
 * Mesh
 *  
 * @author cwei
 */
public abstract class Mesh extends Light {

	// g_mesh.c: triangle model functions
	/*
	=============================================================

	  ALIAS MODELS

	=============================================================
	*/

	static final int NUMVERTEXNORMALS =	162;

	float[][] r_avertexnormals = Anorms.VERTEXNORMALS;
	float[] shadevector = {0, 0, 0};
	float[] shadelight = {0, 0, 0};

	// precalculated dot products for quantized angles
	static final int SHADEDOT_QUANT = 16;

	float[][]	r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS;

	float[] shadedots = r_avertexnormal_dots[0];

	/**
	 * GL_LerpVerts
	 * @param nverts
	 * @param ov
	 * @param verts
	 * @param move
	 * @param frontv
	 * @param backv
	 */
	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;
			}
		}
	}

	FloatBuffer colorArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 4);
	FloatBuffer vertexArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 3);
	FloatBuffer textureArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 2);
	boolean isFilled = false;
	float[] tmpVec = {0, 0, 0};
	float[][] vectors = {
		{0, 0, 0}, {0, 0, 0}, {0, 0, 0} // 3 mal vec3_t
	};
	
	// stack variable
	private final float[] move = {0, 0, 0}; // vec3_t		
	private final float[] frontv = {0, 0, 0}; // vec3_t
	private final float[] backv = {0, 0, 0}; // vec3_t
	/**
	 * GL_DrawAliasFrameLerp
	 * 
	 * interpolates between two frames and origins
	 * FIXME: batch lerp all vertexes
	 */
	void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp)
	{
		qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame];

		int[] verts = frame.verts;

		qfiles.daliasframe_t oldframe = paliashdr.aliasFrames[currententity.oldframe];

		int[] ov = oldframe.verts;

		float	alpha;
		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)
			gl.glDisable( GL_TEXTURE_2D );

		float frontlerp = 1.0f - backlerp;

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

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

		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 );
		
		//gl.gl.glEnableClientState( GL_VERTEX_ARRAY );
		gl.glVertexPointer( 3, 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)
		{
			gl.glColor4f( shadelight[0], shadelight[1], shadelight[2], alpha );
		}
		else
		{
			gl.glEnableClientState( GL_COLOR_ARRAY );
			gl.glColorPointer( 4, 0, colorArrayBuf );

			//
			// pre light everything
			//
			FloatBuffer color = colorArrayBuf;
			float l;
			int size = paliashdr.num_xyz;
			int j = 0;
			for (int i = 0; i < size; 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;
			}
		}

		gl.glClientActiveTextureARB(TEXTURE0);
		gl.glTexCoordPointer( 2, 0, textureArrayBuf);
		//gl.gl.glEnableClientState( 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;
		int count;
		int mode;
		int size = counts.length;
		for (int j = 0; j < size; j++) {

			// get the vertex count and primitive type
			count = counts[j];
			if (count == 0)
				break;		// done
				
			srcIndexBuf = paliashdr.indexElements[j];
			
			mode = GL_TRIANGLE_STRIP;
			if (count < 0) {
				mode = GL_TRIANGLE_FAN;
				count = -count;
			}
			srcIndex = pos << 1;
			srcIndex--;
			for (int k = 0; k < count; k++) {
				dstIndex = srcIndexBuf.get(k) << 1;
				dstTextureCoords.put(dstIndex, srcTextureCoords.get(++srcIndex));
				dstTextureCoords.put(++dstIndex, srcTextureCoords.get(++srcIndex));
			}
				
			gl.glDrawElements(mode, 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 )
			gl.glEnable( GL_TEXTURE_2D );

		gl.glDisableClientState( GL_COLOR_ARRAY );
	}
			
	private final float[] point = {0, 0, 0};
	/**
	 * GL_DrawAliasShadow
	 */
	void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum)
	{
		float lheight = currententity.origin[2] - lightspot[2];
		qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame];
		int[] order = paliashdr.glCmds;
		float height = -lheight + 1.0f;
		
		int orderIndex = 0;
		int index = 0;

		// TODO shadow drawing with vertex arrays

		int count;
		while (true)
		{
			// get the vertex count and primitive type
			count = order[orderIndex++];
			if (count == 0)
				break;		// done
			if (count < 0)
			{
				count = -count;
				gl.glBegin (GL_TRIANGLE_FAN);
			}
			else
				gl.glBegin (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;
				gl.glVertex3f(point[0], point[1], point[2]);

				orderIndex += 3;

			} while (--count != 0);

			gl.glEnd ();
		}	
	}

//	TODO sync with jogl renderer. hoz
	// stack variable
	private final float[] mins = { 0, 0, 0 };
	private final float[] maxs = { 0, 0, 0 };
	/**
	 * R_CullAliasModel
	*/
	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
		*/
		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[YAW] = -tmp[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]);
		}

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


	// bounding box
	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}
	};

//	TODO sync with jogl renderer. hoz
	/**
	 * R_DrawAliasModel
	 */
	void R_DrawAliasModel(entity_t e)
	{
		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
		//
		int i;
		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
			gl.glDepthRange(gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin));

		if ( (currententity.flags & Defines.RF_WEAPONMODEL) != 0 && (r_lefthand.value == 1.0f) )
		{
			gl.glMatrixMode( GL_PROJECTION );
			gl.glPushMatrix();
			gl.glLoadIdentity();
			gl.glScalef( -1, 1, 1 );
			MYgluPerspective( r_newrefdef.fov_y, ( float ) r_newrefdef.width / r_newrefdef.height,  4,  4096);
			gl.glMatrixMode( GL_MODELVIEW );

			gl.glCullFace( GL_BACK );
		}

		gl.glPushMatrix ();
		e.angles[PITCH] = -e.angles[PITCH];	// sigh.
		R_RotateForEntity (e);
		e.angles[PITCH] = -e.angles[PITCH];	// sigh.

		
		
		image_t		skin;
		// 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

		gl.glShadeModel (GL_SMOOTH);

		GL_TexEnv( GL_MODULATE );
		if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 )
		{
			gl.glEnable (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( GL_REPLACE );
		gl.glShadeModel (GL_FLAT);

		gl.glPopMatrix ();

		if ( ( currententity.flags & Defines.RF_WEAPONMODEL ) != 0 && ( r_lefthand.value == 1.0F ) )
		{
			gl.glMatrixMode( GL_PROJECTION );
			gl.glPopMatrix();
			gl.glMatrixMode( GL_MODELVIEW );
			gl.glCullFace( GL_FRONT );
		}

		if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 )
		{
			gl.glDisable (GL_BLEND);
		}

		if ( (currententity.flags & Defines.RF_DEPTHHACK) != 0)
			gl.glDepthRange (gldepthmin, gldepthmax);

		if ( gl_shadows.value != 0.0f && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0)
		{
			gl.glPushMatrix ();
			R_RotateForEntity (e);
			gl.glDisable (GL_TEXTURE_2D);
			gl.glEnable (GL_BLEND);
			gl.glColor4f (0,0,0,0.5f);
			GL_DrawAliasShadow (paliashdr, currententity.frame );
			gl.glEnable (GL_TEXTURE_2D);
			gl.glDisable (GL_BLEND);
			gl.glPopMatrix ();
		}
		gl.glColor4f (1,1,1,1);
	}
}
--- NEW FILE: Model.java ---
/*
 * Model.java
 * Copyright (C) 2003
 *
 * $Id: Model.java,v 1.2 2006/11/21 00:50:46 cawe 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.
[...1319 lines suppressed...]
			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;
		}
	}
		
	static void resetModelArrays() {
		globalModelTextureCoordBuf.rewind();
		globalModelVertexIndexBuf.rewind();
	}
		
	static void modelMemoryUsage() {
		System.out.println("AliasModels: globalVertexBuffer size " + globalModelVertexIndexBuf.position());
	}
}

--- NEW FILE: Main.java ---
/*
 * Main.java
 * Copyright (C) 2003
 *
 * $Id: Main.java,v 1.2 2006/11/21 00:50:46 cawe 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.
[...1487 lines suppressed...]
		
		float[] v;
		
		for (int i = 0; i < NUM_BEAM_SEGS; i++) {
			v = start_points[i];
			gl.glVertex3f(v[0], v[1], v[2]);
			v = end_points[i];
			gl.glVertex3f(v[0], v[1], v[2]);
			v = start_points[(i + 1) % NUM_BEAM_SEGS];
			gl.glVertex3f(v[0], v[1], v[2]);
			v = end_points[(i + 1) % NUM_BEAM_SEGS];
			gl.glVertex3f(v[0], v[1], v[2]);
		}
		gl.glEnd();

		gl.glEnable(GL_TEXTURE_2D);
		gl.glDisable(GL_BLEND);
		gl.glDepthMask(true);
	}
}
--- NEW FILE: Polygon.java ---
/*
 * Polygon.java
 * Copyright (C) 2003
 *
 * $Id: Polygon.java,v 1.2 2006/11/21 00:50:46 cawe 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.fast;

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

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

    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 s1(int index) {
        return buffer.get((index + pos) * STRIDE);
    }

    public final void s1(int index, float value) {
        buffer.put((index + pos) * STRIDE, value);
    }

    public final float t1(int index) {
        return buffer.get((index + pos) * STRIDE + 1);
    }

    public final void t1(int index, float value) {
        buffer.put((index + pos) * STRIDE + 1, value);
    }

    public final float x(int index) {
        return buffer.get((index + pos) * STRIDE + 2);
    }

    public final void x(int index, float value) {
        buffer.put((index + pos) * STRIDE + 2, value);
    }

    public final float y(int index) {
        return buffer.get((index + pos) * STRIDE + 3);
    }

    public final void y(int index, float value) {
        buffer.put((index + pos) * STRIDE + 3, value);
    }

    public final float z(int index) {
        return buffer.get((index + pos) * STRIDE + 4);
    }

    public final void z(int index, float value) {
        buffer.put((index + pos) * STRIDE + 4, value);
    }

    public final float s2(int index) {
        return buffer.get((index + pos) * STRIDE + 5);
    }

    public final void s2(int index, float value) {
        buffer.put((index + pos) * STRIDE + 5, value);
    }

    public final float t2(int index) {
        return buffer.get((index + pos) * STRIDE + 6);
    }

    public final void t2(int index, float value) {
        buffer.put((index + pos) * STRIDE + 6, value);
    }

    public final void beginScrolling(float scroll) {
        int index = pos * STRIDE;
        for (int i = 0; i < numverts; i++, index += STRIDE) {
            scroll += s1_old[i] = buffer.get(index);
            buffer.put(index, scroll);
        }
    }

    public final void endScrolling() {
        int index = pos * STRIDE;
        for (int i = 0; i < numverts; i++, index += STRIDE) {
            buffer.put(index, s1_old[i]);
        }
    }
}
--- NEW FILE: Warp.java ---
/*
 * Warp.java
 * Copyright (C) 2003
 *
 * $Id: Warp.java,v 1.2 2006/11/21 00:50:46 cawe 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.fast;

import jake2.Defines;
import jake2.Globals;
import jake2.qcommon.Com;
import jake2.render.*;
import jake2.util.Math3D;
import jake2.util.Vec3Cache;

/**
 * Warp
 *  
 * @author cwei
 */
public abstract class Warp extends Model {
	// 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;
	float	skyrotate;
	float[] skyaxis = {0, 0, 0};
	image_t[] sky_images = new image_t[6];

	msurface_t	warpface;

	static final int SUBDIVIDE_SIZE = 64;

	/**
	 * BoundPoly
	 * @param numverts
	 * @param verts
	 * @param mins
	 * @param maxs
	 */
	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
	 * @param numverts
	 * @param verts
	 */
	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.
	 */
    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);
    }

// =========================================================
	static final float TURBSCALE = (float)(256.0f / (2 * Math.PI));

	/**
	 * EmitWaterPolys
	 * Does a water warp on the pre-fragmented glpoly_t chain
	 */
	void EmitWaterPolys(msurface_t fa)
	{
		float rdt = r_newrefdef.time;

		float scroll;
		if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0)
			scroll = -64 * ( (r_newrefdef.time*0.5f) - (int)(r_newrefdef.time*0.5f) );
		else
			scroll = 0;
		
		int i;
		float s, t, os, ot;
		glpoly_t p, bp;
        for (bp = fa.polys; bp != null; bp = bp.next) {
            p = bp;

            gl.glBegin(GL_TRIANGLE_FAN);
            for (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);

                gl.glTexCoord2f(s, t);
                gl.glVertex3f(p.x(i), p.y(i), p.z(i));
            }
            gl.glEnd();
        }
	}

//	  ===================================================================

	float[][] skyclip = {
		{ 1,  1, 0},
		{ 1, -1, 0},
		{ 0, -1, 1},
		{ 0,  1, 1},
		{ 1,  0, 1},
		{-1,  0, 1} 
	};

	int c_sky;

	// 1 = s, 2 = t, 3 = 2048
	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

	};

	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;

	// stack variable
	private final float[] v = {0, 0, 0};
	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)
				c...
 
[truncated message content]