cl_ents.java

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

			state.pmove.pm_type = Defines.PM_FREEZE; // demo playback

		//
		// parse the rest of the player_state_t
		//
		if ((flags & Defines.PS_VIEWOFFSET) != 0) {
			state.viewoffset[0] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.viewoffset[1] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.viewoffset[2] = MSG.ReadChar(Globals.net_message) * 0.25f;
		}

		if ((flags & Defines.PS_VIEWANGLES) != 0) {
			state.viewangles[0] = MSG.ReadAngle16(Globals.net_message);
			state.viewangles[1] = MSG.ReadAngle16(Globals.net_message);
			state.viewangles[2] = MSG.ReadAngle16(Globals.net_message);
		}

		if ((flags & Defines.PS_KICKANGLES) != 0) {

			state.kick_angles[0] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.kick_angles[1] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.kick_angles[2] = MSG.ReadChar(Globals.net_message) * 0.25f;

		}

		if ((flags & Defines.PS_WEAPONINDEX) != 0) {
			state.gunindex = MSG.ReadByte(Globals.net_message);
		}

		if ((flags & Defines.PS_WEAPONFRAME) != 0) {
			state.gunframe = MSG.ReadByte(Globals.net_message);
			state.gunoffset[0] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.gunoffset[1] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.gunoffset[2] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.gunangles[0] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.gunangles[1] = MSG.ReadChar(Globals.net_message) * 0.25f;
			state.gunangles[2] = MSG.ReadChar(Globals.net_message) * 0.25f;
		}

		if ((flags & Defines.PS_BLEND) != 0) {
			state.blend[0] = MSG.ReadByte(Globals.net_message) / 255.0f;
			state.blend[1] = MSG.ReadByte(Globals.net_message) / 255.0f;
			state.blend[2] = MSG.ReadByte(Globals.net_message) / 255.0f;
			state.blend[3] = MSG.ReadByte(Globals.net_message) / 255.0f;
		}

		if ((flags & Defines.PS_FOV) != 0)
			state.fov = MSG.ReadByte(Globals.net_message);

		if ((flags & Defines.PS_RDFLAGS) != 0)
			state.rdflags = MSG.ReadByte(Globals.net_message);

		// parse stats
		statbits = MSG.ReadLong(Globals.net_message);
		for (i = 0; i < Defines.MAX_STATS; i++)
			if ((statbits & (1 << i)) != 0)
				state.stats[i] = MSG.ReadShort(Globals.net_message);
	}

	/*
	 * ================== CL_FireEntityEvents
	 * 
	 * ==================
	 */
	public static void FireEntityEvents(frame_t frame) {
		entity_state_t s1;
		int pnum, num;

		for (pnum = 0; pnum < frame.num_entities; pnum++) {
			num = (frame.parse_entities + pnum) & (Defines.MAX_PARSE_ENTITIES - 1);
			s1 = Globals.cl_parse_entities[num];
			if (s1.event != 0)
				CL_fx.EntityEvent(s1);

			// EF_TELEPORTER acts like an event, but is not cleared each frame
			if ((s1.effects & Defines.EF_TELEPORTER) != 0)
				CL_fx.TeleporterParticles(s1);
		}
	}

	/*
	 * ================ CL_ParseFrame ================
	 */
	public static void ParseFrame() {
		int cmd;
		int len;
		frame_t old;

		//memset( cl.frame, 0, sizeof(cl.frame));
		Globals.cl.frame.reset();

		Globals.cl.frame.serverframe = MSG.ReadLong(Globals.net_message);
		Globals.cl.frame.deltaframe = MSG.ReadLong(Globals.net_message);
		Globals.cl.frame.servertime = Globals.cl.frame.serverframe * 100;

		// BIG HACK to let old demos continue to work
		if (Globals.cls.serverProtocol != 26)
			Globals.cl.surpressCount = MSG.ReadByte(Globals.net_message);

		if (Globals.cl_shownet.value == 3)
			Com.Printf("   frame:" + Globals.cl.frame.serverframe + "  delta:" + Globals.cl.frame.deltaframe + "\n");

		// If the frame is delta compressed from data that we
		// no longer have available, we must suck up the rest of
		// the frame, but not use it, then ask for a non-compressed
		// message
		if (Globals.cl.frame.deltaframe <= 0) {
			Globals.cl.frame.valid = true; // uncompressed frame
			old = null;
			Globals.cls.demowaiting = false; // we can start recording now
		} else {
			old = Globals.cl.frames[Globals.cl.frame.deltaframe & Defines.UPDATE_MASK];
			if (!old.valid) { // should never happen
				Com.Printf("Delta from invalid frame (not supposed to happen!).\n");
			}
			if (old.serverframe != Globals.cl.frame.deltaframe) { // The frame
																  // that the
																  // server did
																  // the delta
																  // from
				// is too old, so we can't reconstruct it properly.
				Com.Printf("Delta frame too old.\n");
			} else if (Globals.cl.parse_entities - old.parse_entities > Defines.MAX_PARSE_ENTITIES - 128) {
				Com.Printf("Delta parse_entities too old.\n");
			} else
				Globals.cl.frame.valid = true; // valid delta parse
		}

		// clamp time
		if (Globals.cl.time > Globals.cl.frame.servertime)
			Globals.cl.time = Globals.cl.frame.servertime;
		else if (Globals.cl.time < Globals.cl.frame.servertime - 100)
			Globals.cl.time = Globals.cl.frame.servertime - 100;

		// read areabits
		len = MSG.ReadByte(Globals.net_message);
		MSG.ReadData(Globals.net_message, Globals.cl.frame.areabits, len);

		// read playerinfo
		cmd = MSG.ReadByte(Globals.net_message);
		CL_parse.SHOWNET(CL_parse.svc_strings[cmd]);
		if (cmd != Defines.svc_playerinfo)
			Com.Error(Defines.ERR_DROP, "CL_ParseFrame: not playerinfo");
		ParsePlayerstate(old, Globals.cl.frame);

		// read packet entities
		cmd = MSG.ReadByte(Globals.net_message);
		CL_parse.SHOWNET(CL_parse.svc_strings[cmd]);
		if (cmd != Defines.svc_packetentities)
			Com.Error(Defines.ERR_DROP, "CL_ParseFrame: not packetentities");

		ParsePacketEntities(old, Globals.cl.frame);

		// save the frame off in the backup array for later delta comparisons
		Globals.cl.frames[Globals.cl.frame.serverframe & Defines.UPDATE_MASK].set(Globals.cl.frame);

		if (Globals.cl.frame.valid) {
			// getting a valid frame message ends the connection process
			if (Globals.cls.state != Defines.ca_active) {
				Globals.cls.state = Defines.ca_active;
				Globals.cl.force_refdef = true;

				Globals.cl.predicted_origin[0] = Globals.cl.frame.playerstate.pmove.origin[0] * 0.125f;
				Globals.cl.predicted_origin[1] = Globals.cl.frame.playerstate.pmove.origin[1] * 0.125f;
				Globals.cl.predicted_origin[2] = Globals.cl.frame.playerstate.pmove.origin[2] * 0.125f;

				Math3D.VectorCopy(Globals.cl.frame.playerstate.viewangles, Globals.cl.predicted_angles);
				if (Globals.cls.disable_servercount != Globals.cl.servercount && Globals.cl.refresh_prepped)
					SCR.EndLoadingPlaque(); // get rid of loading plaque
			}
			Globals.cl.sound_prepped = true; // can start mixing ambient sounds

			// fire entity events
			FireEntityEvents(Globals.cl.frame);
			CL_pred.CheckPredictionError();
		}
	}

	/*
	 * ==========================================================================
	 * 
	 * INTERPOLATE BETWEEN FRAMES TO GET RENDERING PARMS
	 * 
	 * ==========================================================================
	 */

	// stack variable
	private static final entity_t ent = new entity_t();
	/*
	 * =============== 
	 * CL_AddPacketEntities
	 * ===============
	 */
	static void AddPacketEntities(frame_t frame) {
		entity_state_t s1;
		float autorotate;
		int i;
		int pnum;
		centity_t cent;
		int autoanim;
		clientinfo_t ci;
		int effects, renderfx;

		// bonus items rotate at a fixed rate
		autorotate = Math3D.anglemod(Globals.cl.time / 10);

		// brush models can auto animate their frames
		autoanim = 2 * Globals.cl.time / 1000;

		//memset( ent, 0, sizeof(ent));
		ent.clear();

		for (pnum = 0; pnum < frame.num_entities; pnum++) {
			s1 = Globals.cl_parse_entities[(frame.parse_entities + pnum) & (Defines.MAX_PARSE_ENTITIES - 1)];

			cent = Globals.cl_entities[s1.number];

			effects = s1.effects;
			renderfx = s1.renderfx;

			// set frame
			if ((effects & Defines.EF_ANIM01) != 0)
				ent.frame = autoanim & 1;
			else if ((effects & Defines.EF_ANIM23) != 0)
				ent.frame = 2 + (autoanim & 1);
			else if ((effects & Defines.EF_ANIM_ALL) != 0)
				ent.frame = autoanim;
			else if ((effects & Defines.EF_ANIM_ALLFAST) != 0)
				ent.frame = Globals.cl.time / 100;
			else
				ent.frame = s1.frame;

			// quad and pent can do different things on client
			if ((effects & Defines.EF_PENT) != 0) {
				effects &= ~Defines.EF_PENT;
				effects |= Defines.EF_COLOR_SHELL;
				renderfx |= Defines.RF_SHELL_RED;
			}

			if ((effects & Defines.EF_QUAD) != 0) {
				effects &= ~Defines.EF_QUAD;
				effects |= Defines.EF_COLOR_SHELL;
				renderfx |= Defines.RF_SHELL_BLUE;
			}
			//	  ======
			//	   PMM
			if ((effects & Defines.EF_DOUBLE) != 0) {
				effects &= ~Defines.EF_DOUBLE;
				effects |= Defines.EF_COLOR_SHELL;
				renderfx |= Defines.RF_SHELL_DOUBLE;
			}

			if ((effects & Defines.EF_HALF_DAMAGE) != 0) {
				effects &= ~Defines.EF_HALF_DAMAGE;
				effects |= Defines.EF_COLOR_SHELL;
				renderfx |= Defines.RF_SHELL_HALF_DAM;
			}
			//	   pmm
			//	  ======
			ent.oldframe = cent.prev.frame;
			ent.backlerp = 1.0f - Globals.cl.lerpfrac;

			if ((renderfx & (Defines.RF_FRAMELERP | Defines.RF_BEAM)) != 0) {
				// step origin discretely, because the frames
				// do the animation properly
				Math3D.VectorCopy(cent.current.origin, ent.origin);
				Math3D.VectorCopy(cent.current.old_origin, ent.oldorigin);
			} else { // interpolate origin
				for (i = 0; i < 3; i++) {
					ent.origin[i] = ent.oldorigin[i] = cent.prev.origin[i] + Globals.cl.lerpfrac
							* (cent.current.origin[i] - cent.prev.origin[i]);
				}
			}

			// create a new entity

			// tweak the color of beams
			if ((renderfx & Defines.RF_BEAM) != 0) { // the four beam colors are
													 // encoded in 32 bits of
													 // skinnum (hack)
				ent.alpha = 0.30f;
				ent.skinnum = (s1.skinnum >> ((Globals.rnd.nextInt(4)) * 8)) & 0xff;
				Math.random();
				ent.model = null;
			} else {
				// set skin
				if (s1.modelindex == 255) { // use custom player skin
					ent.skinnum = 0;
					ci = Globals.cl.clientinfo[s1.skinnum & 0xff];
					ent.skin = ci.skin;
					ent.model = ci.model;
					if (null == ent.skin || null == ent.model) {
						ent.skin = Globals.cl.baseclientinfo.skin;
						ent.model = Globals.cl.baseclientinfo.model;
					}

					//	  ============
					//	  PGM
					if ((renderfx & Defines.RF_USE_DISGUISE) != 0) {
						if (ent.skin.name.startsWith("players/male")) {
							ent.skin = Globals.re.RegisterSkin("players/male/disguise.pcx");
							ent.model = Globals.re.RegisterModel("players/male/tris.md2");
						} else if (ent.skin.name.startsWith("players/female")) {
							ent.skin = Globals.re.RegisterSkin("players/female/disguise.pcx");
							ent.model = Globals.re.RegisterModel("players/female/tris.md2");
						} else if (ent.skin.name.startsWith("players/cyborg")) {
							ent.skin = Globals.re.RegisterSkin("players/cyborg/disguise.pcx");
							ent.model = Globals.re.RegisterModel("players/cyborg/tris.md2");
						}
					}
					//	  PGM
					//	  ============
				} else {
					ent.skinnum = s1.skinnum;
					ent.skin = null;
					ent.model = Globals.cl.model_draw[s1.modelindex];
				}
			}

			// only used for black hole model right now, FIXME: do better
			if (renderfx == Defines.RF_TRANSLUCENT)
				ent.alpha = 0.70f;

			// render effects (fullbright, translucent, etc)
			if ((effects & Defines.EF_COLOR_SHELL) != 0)
				ent.flags = 0; // renderfx go on color shell entity
			else
				ent.flags = renderfx;

			// calculate angles
			if ((effects & Defines.EF_ROTATE) != 0) { // some bonus items
													  // auto-rotate
				ent.angles[0] = 0;
				ent.angles[1] = autorotate;
				ent.angles[2] = 0;
			}
			// RAFAEL
			else if ((effects & Defines.EF_SPINNINGLIGHTS) != 0) {
				ent.angles[0] = 0;
				ent.angles[1] = Math3D.anglemod(Globals.cl.time / 2) + s1.angles[1];
				ent.angles[2] = 180;
				{
					float[] forward = { 0, 0, 0 };
					float[] start = { 0, 0, 0 };

					Math3D.AngleVectors(ent.angles, forward, null, null);
					Math3D.VectorMA(ent.origin, 64, forward, start);
					V.AddLight(start, 100, 1, 0, 0);
				}
			} else { // interpolate angles
				float a1, a2;

				for (i = 0; i < 3; i++) {
					a1 = cent.current.angles[i];
					a2 = cent.prev.angles[i];
					ent.angles[i] = Math3D.LerpAngle(a2, a1, Globals.cl.lerpfrac);
				}
			}

			if (s1.number == Globals.cl.playernum + 1) {
				ent.flags |= Defines.RF_VIEWERMODEL; // only draw from mirrors
				// FIXME: still pass to refresh

				if ((effects & Defines.EF_FLAG1) != 0)
					V.AddLight(ent.origin, 225, 1.0f, 0.1f, 0.1f);
				else if ((effects & Defines.EF_FLAG2) != 0)
					V.AddLight(ent.origin, 225, 0.1f, 0.1f, 1.0f);
				else if ((effects & Defines.EF_TAGTRAIL) != 0) //PGM
					V.AddLight(ent.origin, 225, 1.0f, 1.0f, 0.0f); //PGM
				else if ((effects & Defines.EF_TRACKERTRAIL) != 0) //PGM
					V.AddLight(ent.origin, 225, -1.0f, -1.0f, -1.0f); //PGM

				continue;
			}

			// if set to invisible, skip
			if (s1.modelindex == 0)
				continue;

			if ((effects & Defines.EF_BFG) != 0) {
				ent.flags |= Defines.RF_TRANSLUCENT;
				ent.alpha = 0.30f;
			}

			// RAFAEL
			if ((effects & Defines.EF_PLASMA) != 0) {
				ent.flags |= Defines.RF_TRANSLUCENT;
				ent.alpha = 0.6f;
			}

			if ((effects & Defines.EF_SPHERETRANS) != 0) {
				ent.flags |= Defines.RF_TRANSLUCENT;
				// PMM - *sigh* yet more EF overloading
				if ((effects & Defines.EF_TRACKERTRAIL) != 0)
					ent.alpha = 0.6f;
				else
					ent.alpha = 0.3f;
			}
			//	  pmm

			// add to refresh list
			V.AddEntity(ent);

			// color shells generate a seperate entity for the main model
			if ((effects & Defines.EF_COLOR_SHELL) != 0) {