image.java

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

							GL11.GL_TEXTURE_2D,
							0,
							GL_COLOR_INDEX8_EXT,
							scaled_width,
							scaled_height,
							0,
							GL11.GL_COLOR_INDEX,
							GL11.GL_UNSIGNED_BYTE,
							paletted_texture);
					}
					else {
						tex.rewind(); tex.put(data); tex.rewind();
						gl.glTexImage2D(
							GL11.GL_TEXTURE_2D,
							0,
							comp,
							scaled_width,
							scaled_height,
							0,
							GL11.GL_RGBA,
							GL11.GL_UNSIGNED_BYTE,
							tex);
					}
					//goto done;
					throw gotoDone;
				}
				//memcpy (scaled, data, width*height*4); were bytes
				System.arraycopy(data, 0, scaled, 0, width * height);
			}
			else
				GL_ResampleTexture(data, width, height, scaled, scaled_width, scaled_height);

			GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap);

			if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && (samples == gl_solid_format)) {
				uploaded_paletted = true;
				GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height);
				gl.glTexImage2D(
					GL11.GL_TEXTURE_2D,
					0,
					GL_COLOR_INDEX8_EXT,
					scaled_width,
					scaled_height,
					0,
					GL11.GL_COLOR_INDEX,
					GL11.GL_UNSIGNED_BYTE,
					paletted_texture);
			}
			else {
				tex.rewind(); tex.put(scaled); tex.rewind();
				gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, tex);
			}

			if (mipmap) {
				int miplevel;
				miplevel = 0;
				while (scaled_width > 1 || scaled_height > 1) {
					GL_MipMap(scaled, scaled_width, scaled_height);
					scaled_width >>= 1;
					scaled_height >>= 1;
					if (scaled_width < 1)
						scaled_width = 1;
					if (scaled_height < 1)
						scaled_height = 1;

					miplevel++;
					if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && samples == gl_solid_format) {
						uploaded_paletted = true;
						GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height);
						gl.glTexImage2D(
							GL11.GL_TEXTURE_2D,
							miplevel,
							GL_COLOR_INDEX8_EXT,
							scaled_width,
							scaled_height,
							0,
							GL11.GL_COLOR_INDEX,
							GL11.GL_UNSIGNED_BYTE,
							paletted_texture);
					}
					else {
						tex.rewind(); tex.put(scaled); tex.rewind();
						gl.glTexImage2D(
							GL11.GL_TEXTURE_2D,
							miplevel,
							comp,
							scaled_width,
							scaled_height,
							0,
							GL11.GL_RGBA,
							GL11.GL_UNSIGNED_BYTE,
							tex);
					}
				}
			}
			// label done:
		}
		catch (Throwable e) {
			// replaces label done
		}

		if (mipmap) {
			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, gl_filter_min);
			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, gl_filter_max);
		}
		else {
			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, gl_filter_max);
			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, gl_filter_max);
		}

		return (samples == gl_alpha_format);
	}

	/*
	===============
	GL_Upload8
	
	Returns has_alpha
	===============
	*/

	int[] trans = new int[512 * 256];

	boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, boolean is_sky) {
		
		Arrays.fill(trans, 0);

		int s = width * height;

		if (s > trans.length)
			Com.Error(Defines.ERR_DROP, "GL_Upload8: too large");

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

			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, gl_filter_max);
			gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.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
		//
		image = null;
		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);

		}

		return image;
	}

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

	IntBuffer texnumBuffer=BufferUtils.createIntBuffer(1);
	
	/*
	================
	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
			texnumBuffer.clear();
			texnumBuffer.put(0,image.texnum);
			gl.glDeleteTextures(texnumBuffer);
			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
			texnumBuffer.clear();
			texnumBuffer.put(0,image.texnum);
			gl.glDeleteTextures(texnumBuffer);
	  		image.clear();
		}
	}

}