image.java

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

        if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) {
            gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width,
                    height, 0, GL.GL_COLOR_INDEX, GL.GL_UNSIGNED_BYTE, data);

            gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER,
                    gl_filter_max);
            gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER,
                    gl_filter_max);

            // TODO check this
            return false;
        } else {
            int p;
            int rgb;
            for (int i = 0; i < s; i++) {
                p = data[i] & 0xff;
                trans[i] = d_8to24table[p];

                if (p == 255) { // transparent, so scan around for another color
                    // to avoid alpha fringes
                    // FIXME: do a full flood fill so mips work...
                    if (i > width && (data[i - width] & 0xff) != 255)
                        p = data[i - width] & 0xff;
                    else if (i < s - width && (data[i + width] & 0xff) != 255)
                        p = data[i + width] & 0xff;
                    else if (i > 0 && (data[i - 1] & 0xff) != 255)
                        p = data[i - 1] & 0xff;
                    else if (i < s - 1 && (data[i + 1] & 0xff) != 255)
                        p = data[i + 1] & 0xff;
                    else
                        p = 0;
                    // copy rgb components

                    // ((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0];
                    // ((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1];
                    // ((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2];

                    trans[i] = d_8to24table[p] & 0x00FFFFFF; // only rgb
                }
            }

            return GL_Upload32(trans, width, height, mipmap);
        }
    }

    /*
     * ================ GL_LoadPic
     * 
     * This is also used as an entry point for the generated r_notexture
     * ================
     */
    image_t GL_LoadPic(String name, byte[] pic, int width, int height,
            int type, int bits) {
        image_t image;
        int i;

        // find a free image_t
        for (i = 0; i < numgltextures; i++) {
            image = gltextures[i];
            if (image.texnum == 0)
                break;
        }

        if (i == numgltextures) {
            if (numgltextures == MAX_GLTEXTURES)
                Com.Error(Defines.ERR_DROP, "MAX_GLTEXTURES");

            numgltextures++;
        }
        image = gltextures[i];

        if (name.length() > Defines.MAX_QPATH)
            Com.Error(Defines.ERR_DROP, "Draw_LoadPic: \"" + name
                    + "\" is too long");

        image.name = name;
        image.registration_sequence = registration_sequence;

        image.width = width;
        image.height = height;
        image.type = type;

        if (type == it_skin && bits == 8)
            R_FloodFillSkin(pic, width, height);

        // load little pics into the scrap
        if (image.type == it_pic && bits == 8 && image.width < 64
                && image.height < 64) {
            pos_t pos = new pos_t(0, 0);
            int j, k;

            int texnum = Scrap_AllocBlock(image.width, image.height, pos);

            if (texnum == -1) {
                // replace goto nonscrap

                image.scrap = false;

                image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in
                                                              // array
                GL_Bind(image.texnum);

                if (bits == 8) {
                    image.has_alpha = GL_Upload8(pic, width, height,
                            (image.type != it_pic && image.type != it_sky),
                            image.type == it_sky);
                } else {
                    int[] tmp = new int[pic.length / 4];

                    for (i = 0; i < tmp.length; i++) {
                        tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // &
                                                                 // 0x000000FF;
                        tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // &
                                                                  // 0x0000FF00;
                        tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // &
                                                                   // 0x00FF0000;
                        tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // &
                                                                   // 0xFF000000;
                    }

                    image.has_alpha = GL_Upload32(tmp, width, height,
                            (image.type != it_pic && image.type != it_sky));
                }

                image.upload_width = upload_width; // after power of 2 and
                                                   // scales
                image.upload_height = upload_height;
                image.paletted = uploaded_paletted;
                image.sl = 0;
                image.sh = 1;
                image.tl = 0;
                image.th = 1;

                return image;
            }

            scrap_dirty = true;

            // copy the texels into the scrap block
            k = 0;
            for (i = 0; i < image.height; i++)
                for (j = 0; j < image.width; j++, k++)
                    scrap_texels[texnum][(pos.y + i) * BLOCK_WIDTH + pos.x + j] = pic[k];

            image.texnum = TEXNUM_SCRAPS + texnum;
            image.scrap = true;
            image.has_alpha = true;
            image.sl = (pos.x + 0.01f) / (float) BLOCK_WIDTH;
            image.sh = (pos.x + image.width - 0.01f) / (float) BLOCK_WIDTH;
            image.tl = (pos.y + 0.01f) / (float) BLOCK_WIDTH;
            image.th = (pos.y + image.height - 0.01f) / (float) BLOCK_WIDTH;

        } else {
            // this was label nonscrap

            image.scrap = false;

            image.texnum = TEXNUM_IMAGES + image.getId(); //image pos in array
            GL_Bind(image.texnum);

            if (bits == 8) {
                image.has_alpha = GL_Upload8(pic, width, height,
                        (image.type != it_pic && image.type != it_sky),
                        image.type == it_sky);
            } else {
                int[] tmp = new int[pic.length / 4];

                for (i = 0; i < tmp.length; i++) {
                    tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF;
                    tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00;
                    tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000;
                    tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000;
                }

                image.has_alpha = GL_Upload32(tmp, width, height,
                        (image.type != it_pic && image.type != it_sky));
            }
            image.upload_width = upload_width; // after power of 2 and scales
            image.upload_height = upload_height;
            image.paletted = uploaded_paletted;
            image.sl = 0;
            image.sh = 1;
            image.tl = 0;
            image.th = 1;
        }
        return image;
    }

    /*
     * ================ GL_LoadWal ================
     */
    image_t GL_LoadWal(String name) {

        image_t image = null;

        byte[] raw = FS.LoadFile(name);
        if (raw == null) {
            VID.Printf(Defines.PRINT_ALL, "GL_FindImage: can't load " + name
                    + '\n');
            return r_notexture;
        }

        qfiles.miptex_t mt = new qfiles.miptex_t(raw);

        byte[] pix = new byte[mt.width * mt.height];
        System.arraycopy(raw, mt.offsets[0], pix, 0, pix.length);

        image = GL_LoadPic(name, pix, mt.width, mt.height, it_wall, 8);

        return image;
    }

    /*
     * =============== GL_FindImage
     * 
     * Finds or loads the given image ===============
     */
    image_t GL_FindImage(String name, int type) {
        image_t image = null;

        // TODO loest das grossschreibungs problem
        name = name.toLowerCase();
        // bughack for bad strings (fuck \0)
        int index = name.indexOf('\0');
        if (index != -1)
            name = name.substring(0, index);

        if (name == null || name.length() < 5)
            return null; //	Com.Error (ERR_DROP, "GL_FindImage: NULL name");
        //	Com.Error (ERR_DROP, "GL_FindImage: bad name: %s", name);

        // look for it
        for (int i = 0; i < numgltextures; i++) {
            image = gltextures[i];
            if (name.equals(image.name)) {
                image.registration_sequence = registration_sequence;
                return image;
            }
        }

        //
        // load the pic from disk
        //
        byte[] pic = null;
        Dimension dim = new Dimension();

        if (name.endsWith(".pcx")) {

            pic = LoadPCX(name, null, dim);
            if (pic == null)
                return null;
            image = GL_LoadPic(name, pic, dim.width, dim.height, type, 8);

        } else if (name.endsWith(".wal")) {

            image = GL_LoadWal(name);

        } else if (name.endsWith(".tga")) {

            pic = LoadTGA(name, dim);

            if (pic == null)
                return null;

            image = GL_LoadPic(name, pic, dim.width, dim.height, type, 32);

        } else
            return null;

        return image;
    }

    /*
     * =============== R_RegisterSkin ===============
     */
    protected image_t R_RegisterSkin(String name) {
        return GL_FindImage(name, it_skin);
    }

    /*
     * ================ GL_FreeUnusedImages
     * 
     * Any image that was not touched on this registration sequence will be
     * freed. ================
     */
    void GL_FreeUnusedImages() {

        // never free r_notexture or particle texture
        r_notexture.registration_sequence = registration_sequence;
        r_particletexture.registration_sequence = registration_sequence;

        image_t image = null;

        for (int i = 0; i < numgltextures; i++) {
            image = gltextures[i];
            // used this sequence
            if (image.registration_sequence == registration_sequence)
                continue;
            // free image_t slot
            if (image.registration_sequence == 0)
                continue;
            // don't free pics
            if (image.type == it_pic)
                continue;

            // free it
            // TODO jogl bug
            gl.glDeleteTextures(1, new int[] { image.texnum });
            image.clear();
        }
    }

    /*
     * =============== Draw_GetPalette ===============
     */
    protected void Draw_GetPalette() {
        int r, g, b;
        Dimension dim;
        byte[] pic;
        byte[][] palette = new byte[1][]; //new byte[768];

        // get the palette

        pic = LoadPCX("pics/colormap.pcx", palette, dim = new Dimension());

        if (palette[0] == null || palette[0].length != 768)
            Com.Error(Defines.ERR_FATAL, "Couldn't load pics/colormap.pcx");

        byte[] pal = palette[0];

        int j = 0;
        for (int i = 0; i < 256; i++) {
            r = pal[j++] & 0xFF;
            g = pal[j++] & 0xFF;
            b = pal[j++] & 0xFF;

            d_8to24table[i] = (255 << 24) | (b << 16) | (g << 8) | (r << 0);
        }

        d_8to24table[255] &= 0x00FFFFFF; // 255 is transparent

        particle_t.setColorPalette(d_8to24table);
    }

    /*
     * =============== GL_InitImages ===============
     */
    void GL_InitImages() {
        int i, j;
        float g = vid_gamma.value;

        registration_sequence = 1;

        // init intensity conversions
        intensity = Cvar.Get("intensity", "2", 0);

        if (intensity.value <= 1)
            Cvar.Set("intensity", "1");

        gl_state.inverse_intensity = 1 / intensity.value;

        Draw_GetPalette();

        if (qglColorTableEXT) {
            gl_state.d_16to8table = FS.LoadFile("pics/16to8.dat");
            if (gl_state.d_16to8table == null)
                Com.Error(Defines.ERR_FATAL, "Couldn't load pics/16to8.pcx");
        }

        if ((gl_config.renderer & (GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2)) != 0) {
            g = 1.0F;
        }

        for (i = 0; i < 256; i++) {

            if (g == 1.0f) {
                gammatable[i] = (byte) i;
            } else {

                int inf = (int) (255.0f * Math.pow((i + 0.5) / 255.5, g) + 0.5);
                if (inf < 0)
                    inf = 0;
                if (inf > 255)
                    inf = 255;
                gammatable[i] = (byte) inf;
            }
        }

        for (i = 0; i < 256; i++) {
            j = (int) (i * intensity.value);
            if (j > 255)
                j = 255;
            intensitytable[i] = (byte) j;
        }
    }

    /*
     * =============== 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
            // TODO jogl bug
            gl.glDeleteTextures(1, new int[] { image.texnum });
            image.clear();
        }
    }

}