jake2-commits Mailing List for Jake2 (Page 14)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

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

Added Files:
      Tag: render-refactoring
	Light.java Polygon.java Warp.java Surf.java Main.java 
	Image.java Mesh.java Misc.java Anorms.java Model.java 
	Draw.java 
Log Message:
(only for testing and history)

--- NEW FILE: Image.java ---
/*
 * Image.java
 * Copyright (C) 2003
 *
 * $Id$
 */
/*
 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.
[...1554 lines suppressed...]
    }

    /*
     * GL_ShutdownImages
     */
    void GL_ShutdownImages() {
        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
            texnum.put(0, image.texnum);
            gl.glDeleteTextures(texnum);
            image.clear();
        }
    }
}
--- NEW FILE: Surf.java ---
/*
 * Surf.java
 * Copyright (C) 2003
 *
 * $Id$
 */
/*
 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.
[...1244 lines suppressed...]
    //		
    //		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$
 */
/*
 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.fastj;

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
     * 
     * =============================================================================
     */

    void R_RenderDlight(dlight_t light) {
        float rad = light.intensity * 0.35f;
        float[] v = Vec3Cache.get();
        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);
        for (int 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);
        float a;
        for (int i = 16; i >= 0; i--) {
            a = (float) (i / 16.0f * Math.PI * 2);
            for (int 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();
        Vec3Cache.release();
    }

    /*
     * ============= 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;
        }

        msurface_t surf;
        int sidebit;
        // mark the polygons
        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

    float scalef = 1.0f/255;

    int RecursiveLightPoint(mnode_t node, float[] start, float[] end) {
        if (node.contents != -1)
            return -1; // didn't hit anything

//        ByteBuffer lightmap;
//        int maps;

        // 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();
            return r; // hit something
        }

        if ((back < 0) == side) {
            Vec3Cache.release();
            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;
        mtexinfo_t tex;
		float scale0;
		float scale1;
		float scale2;
		int s, t, ds, dt;
		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);

                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 * scalef;
                    pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF)
                            * scale1 * scalef;
                    pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF)
                            * scale2 * scalef;
                    lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1)
                            * ((surf.extents[1] >> 4) + 1);
                }
            }
            Vec3Cache.release();
            return 1;
        }

        // go down back side
		r = RecursiveLightPoint(node.children[1 - sideIndex], mid, end);
        Vec3Cache.release();
        return r;
    }

    /*
     * =============== 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;
        }

        float[] end = Vec3Cache.get();
        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
        //
        float add;
        dlight_t dl;
        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));

            if (add > 0) {
                Math3D.VectorMA(color, add * scalef, dl.color, color);
            }
        }

        Math3D.VectorScale(color, gl_modulate.value, color);
        Vec3Cache.release();
    }

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

    float[] s_blocklights = new float[34 * 34 * 3];

    /*
     * =============== R_AddDynamicLights ===============
     */
    // TODO sync with jogl renderer. hoz
    void R_AddDynamicLights(msurface_t surf) {
        int sd, td;
        float fdist, frad, fminlight;
        float[] impact = Vec3Cache.get();
        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;
        float 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];
                    }
                }
            }
        }
        Vec3Cache.release();
    }

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

    // replaces the goto jump
    private Throwable gotoStore = new Throwable();

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

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

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

    void GL_LerpVerts(int nverts, int[] ov, int[] v, float[] move, float[] frontv,
            float[] backv) {
        int ovv, vv;
        FloatBuffer lerp = vertexArrayBuf;

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

    /*
     * ============= GL_DrawAliasFrameLerp
     * 
     * interpolates between two frames and origins FIXME: batch lerp all
     * vertexes =============
     */

    void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp) {
        int count;
        float alpha;

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

        int[] verts = frame.verts;

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

        int[] ov = oldframe.verts;

        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;

        float[] frontv = Vec3Cache.get(); // vec3_t
        // 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]);

        float[] move = Vec3Cache.get(); // vec3_t
        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);

        float[] backv = Vec3Cache.get(); // vec3_t
        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);

        Vec3Cache.release(3); // frontv, move, backv

        //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;
            int j = 0;
            float l;
            for (int i = 0; i < paliashdr.num_xyz; 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(GL_TEXTURE0);
        gl.glTexCoordPointer(2, 0, textureArrayBuf);
        //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;

        for (int j = 0; j < counts.length; j++) {

            // get the vertex count and primitive type
            count = counts[j];
            if (count == 0)
                break; // done

            srcIndexBuf = paliashdr.indexElements[j];

            int mode = GL_TRIANGLE_STRIP;
            if (count < 0) {
                mode = GL_TRIANGLE_FAN;
                count = -count;
            }
            srcIndex = pos << 1;
            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);

    }

    /*
     * ============= GL_DrawAliasShadow =============
     */
    void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum) {
        int[] order;
        float height, lheight;
        int count;
        qfiles.daliasframe_t frame;

        lheight = currententity.origin[2] - lightspot[2];

        frame = paliashdr.aliasFrames[currententity.frame];

        height = 0;

        order = paliashdr.glCmds;

        height = -lheight + 1.0f;

        int orderIndex = 0;
        int index = 0;

        // TODO shadow drawing with vertex arrays

        float[] point = Vec3Cache.get();
        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();
        }
        Vec3Cache.release(); // point
    }

    /*
     * * R_CullAliasModel
     */
    //	TODO sync with jogl renderer. hoz
    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
         */
        float[] mins = Vec3Cache.get();
        float[] maxs = Vec3Cache.get();

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

        Vec3Cache.release(2); // mins, maxs

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

    /*
     * ================= R_DrawAliasModel
     * 
     * =================
     */
    //	TODO sync with jogl renderer. hoz
    void R_DrawAliasModel(entity_t e) {
        int i;
        //qfiles.dmdl_t paliashdr;
        //float an;

        image_t skin;

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

        // 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$
 */
/*
 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.
[...1223 lines suppressed...]
            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$
 */
/*
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.
[...1512 lines suppressed...]
		float[] v;

		for (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$
 */
/*
 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.fastj;

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

    public final void s1(int index, float value) {
        buffer.put(offset(index), value);
    }

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

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

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

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

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

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

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

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

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

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

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

    public final void t2(int index, float value) {
        buffer.put(offset(index) + 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]);
        }
    }

    private final int offset(int index) {
        return (index + pos) * STRIDE;
    }
}
--- NEW FILE: Warp.java ---
/*
 * Warp.java
 * Copyright (C) 2003
 *
 * $Id$
 */
/*
 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.fastj;

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

    // gl_warp.c -- sky and water polygons
    //extern model_t *loadmodel; // Model.java

    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;

    void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs) {
        int i, j;
        float[] v;

        mins[0] = mins[1] = mins[2] = 9999;
        maxs[0] = maxs[1] = maxs[2] = -9999;
        for (i = 0;...

[truncated message content]

2004	Jan	Feb	Mar	Apr	May	Jun	Jul (52)	Aug (34)	Sep (99)	Oct (110)	Nov (21)	Dec (69)
2005	Jan (117)	Feb (90)	Mar (1)	Apr (22)	May (96)	Jun (25)	Jul (22)	Aug	Sep	Oct (18)	Nov (43)	Dec (71)
2006	Jan (20)	Feb (10)	Mar	Apr (4)	May (2)	Jun	Jul	Aug (3)	Sep	Oct (60)	Nov (63)	Dec (35)
2007	Jan (18)	Feb (40)	Mar (14)	Apr (18)	May (33)	Jun (2)	Jul	Aug	Sep	Oct	Nov (1)	Dec
2008	Jan	Feb (1)	Mar (25)	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2009	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (5)
2011	Jan	Feb	Mar	Apr	May	Jun	Jul (15)	Aug	Sep	Oct	Nov (3)	Dec
2012	Jan	Feb	Mar	Apr (3)	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

jake2-commits Mailing List for Jake2 (Page 14)

jake2-commits — Jake2 cvs commits