/* * Mesh.java * Copyright (C) 2003 * * $Id: Mesh.java,v 1.12 2005/06/09 07:59:58 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.fastjogl;import jake2.Defines;import jake2.client.VID;import jake2.client.entity_t;import jake2.qcommon.qfiles;import jake2.render.image_t;import jake2.util.Math3D;import jake2.util.Vec3Cache;import java.nio.FloatBuffer;import java.nio.IntBuffer;import net.java.games.jogl.GL;import net.java.games.jogl.util.BufferUtils;/** * 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 = BufferUtils            .newFloatBuffer(qfiles.MAX_VERTS * 4);    FloatBuffer vertexArrayBuf = BufferUtils            .newFloatBuffer(qfiles.MAX_VERTS * 3);    FloatBuffer textureArrayBuf = BufferUtils            .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.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.GL_VERTEX_ARRAY );        gl.glVertexPointer(3, GL.GL_FLOAT, 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.GL_COLOR_ARRAY);            gl.glColorPointer(4, GL.GL_FLOAT, 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, GL.GL_FLOAT, 0, textureArrayBuf);        //gl.glEnableClientState( GL.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.GL_TRIANGLE_STRIP;            if (count < 0) {                mode = GL.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, count, GL.GL_UNSIGNED_INT, 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.GL_TEXTURE_2D);        gl.glDisableClientState(GL.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.GL_TRIANGLE_FAN);            } else                gl.glBegin(GL.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();