Networking improvements to NSEntity, NSRenderableEntity and NSSurfacePropEntity

src/client/entities.qc

@@ -26,11 +26,10 @@ Entity_EntityUpdate(float type, float new)
 		me.ReceiveEntity(new, readfloat());
 		break;
 	case ENT_ENTITYRENDERABLE:
-		NSRenderableEntity rend = (NSRenderableEntity)self;
+		NSRenderableEntity_ReadEntity(new);
-		if (new) {
+		break;
-			spawnfunc_NSRenderableEntity();
+	case ENT_SURFPROP:
-		}
+		NSSurfacePropEntity_ReadEntity(new);
-		rend.ReceiveEntity(new, readfloat());
 		break;
 	case ENT_PHYSICS:
 		NSPhysicsEntity_ReadEntity(new);

src/gs-entbase/baseentity.h

@@ -54,28 +54,4 @@ enum
 };
 #endif
 
-enumflags
-{
-	BASEFL_CHANGED_ORIGIN,
-	BASEFL_CHANGED_ANGLES,
-	BASEFL_CHANGED_MODELINDEX,
-	BASEFL_CHANGED_SIZE,
-	BASEFL_CHANGED_FLAGS,
-	BASEFL_CHANGED_SOLID,
-	BASEFL_CHANGED_FRAME,
-	BASEFL_CHANGED_SKIN,
-	BASEFL_CHANGED_MOVETYPE,
-	BASEFL_CHANGED_EFFECTS,
-	BASEFL_CHANGED_BODY,
-	BASEFL_CHANGED_SCALE,
-	BASEFL_CHANGED_VELOCITY,
-#ifdef GS_RENDERFX
-	BASEFL_CHANGED_RENDERCOLOR,
-	BASEFL_CHANGED_RENDERAMT,
-	BASEFL_CHANGED_RENDERMODE,
-#else
-	BASEFL_CHANGED_ALPHA,
-#endif
-};
-
 .bool _mapspawned;

src/gs-entbase/shared/NSEntity.h

@@ -14,10 +14,33 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+enumflags
+{
+	BASEFL_CHANGED_ORIGIN,
+	BASEFL_CHANGED_ANGLES,
+	BASEFL_CHANGED_MODELINDEX,
+	BASEFL_CHANGED_SIZE,
+	BASEFL_CHANGED_FLAGS,
+	BASEFL_CHANGED_SOLID,
+	BASEFL_CHANGED_FRAME,
+	BASEFL_CHANGED_SKIN,
+	BASEFL_CHANGED_MOVETYPE,
+	BASEFL_CHANGED_EFFECTS,
+	BASEFL_CHANGED_BODY,
+	BASEFL_CHANGED_SCALE,
+	BASEFL_CHANGED_VELOCITY,
+#ifdef GS_RENDERFX
+	BASEFL_CHANGED_RENDERCOLOR,
+	BASEFL_CHANGED_RENDERAMT,
+	BASEFL_CHANGED_RENDERMODE,
+#else
+	BASEFL_CHANGED_ALPHA,
+#endif
+};
+
 /* NSEntity is the lowest, user accessible class.
    It's responsible for handling practically every entity in Nuclide.
 */
-
 class NSEntity:NSTrigger
 {
 	void(void) NSEntity;

src/gs-entbase/shared/NSEntity.qc

@@ -429,6 +429,7 @@ NSEntity::EvaluateEntity(void)
 	}
 
 	SAVE_STATE(origin);
+	angles = Math_FixDeltaVector(angles);
 	SAVE_STATE(angles);
 	SAVE_STATE(modelindex);
 	SAVE_STATE(size);

src/gs-entbase/shared/NSRenderableEntity.h

@@ -14,6 +14,34 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+enumflags
+{
+	RDENT_CHANGED_ORIGIN_X,
+	RDENT_CHANGED_ORIGIN_Y,
+	RDENT_CHANGED_ORIGIN_Z,
+	RDENT_CHANGED_ANGLES_X,
+	RDENT_CHANGED_ANGLES_Y,
+	RDENT_CHANGED_ANGLES_Z,
+	RDENT_CHANGED_MODELINDEX,
+	RDENT_CHANGED_SIZE,
+	RDENT_CHANGED_FLAGS,
+	RDENT_CHANGED_SOLID,
+	RDENT_CHANGED_FRAME,
+	RDENT_CHANGED_SKIN,
+	RDENT_CHANGED_MOVETYPE,
+	RDENT_CHANGED_EFFECTS,
+	RDENT_CHANGED_BODY,
+	RDENT_CHANGED_SCALE,
+	RDENT_CHANGED_VELOCITY,
+#ifdef GS_RENDERFX
+	RDENT_CHANGED_RENDERCOLOR,
+	RDENT_CHANGED_RENDERAMT,
+	RDENT_CHANGED_RENDERMODE,
+#else
+	RDENT_CHANGED_ALPHA,
+#endif
+};
+
 #ifdef CLIENT
 var int autocvar_cl_showtriggers = FALSE;
 var int autocvar_rm_unlit_additive = TRUE;
@@ -28,12 +56,12 @@ class NSRenderableEntity:NSEntity
 	/* overrides */
 	virtual void(string, string) SpawnKey;
 #ifdef SERVER
-	virtual float(entity, float) SendEntity;
 	virtual void(entity, string, string) Input;
 	virtual void(void) Respawn;
 	virtual void(float) Save;
 	virtual void(string,string) Restore;
 	virtual void(void) EvaluateEntity;
+	virtual float(entity, float) SendEntity;
 #else
 	virtual void(float,float) ReceiveEntity;
 	virtual float(void) predraw;

src/gs-entbase/shared/NSRenderableEntity.qc

@@ -51,44 +51,57 @@ NSRenderableEntity::MakeStatic(void)
 void
 NSRenderableEntity::EvaluateEntity(void)
 {
-	if (ATTR_CHANGED(origin)) {
+	if (VEC_CHANGED(origin,0)) {
-		SetSendFlags(BASEFL_CHANGED_ORIGIN);
+		SetSendFlags(RDENT_CHANGED_ORIGIN_X);
 	}
-	if (ATTR_CHANGED(angles)) {
+	if (VEC_CHANGED(origin,1)) {
-		SetSendFlags(BASEFL_CHANGED_ANGLES);
+		SetSendFlags(RDENT_CHANGED_ORIGIN_Y);
+	}
+	if (VEC_CHANGED(origin,2)) {
+		SetSendFlags(RDENT_CHANGED_ORIGIN_Z);
+	}
+	if (VEC_CHANGED(angles,0)) {
+		SetSendFlags(RDENT_CHANGED_ANGLES_X);
+	}
+	if (VEC_CHANGED(angles,1)) {
+		SetSendFlags(RDENT_CHANGED_ANGLES_Y);
+	}
+	if (VEC_CHANGED(angles,2)) {
+		SetSendFlags(RDENT_CHANGED_ANGLES_Z);
 	}
 	if (ATTR_CHANGED(modelindex)) {
-		SetSendFlags(BASEFL_CHANGED_MODELINDEX);
+		SetSendFlags(RDENT_CHANGED_MODELINDEX);
 	}
 	if (ATTR_CHANGED(solid)) {
-		SetSendFlags(BASEFL_CHANGED_SOLID);
+		SetSendFlags(RDENT_CHANGED_SOLID);
 	}
 	if (ATTR_CHANGED(movetype)) {
-		SetSendFlags(BASEFL_CHANGED_MOVETYPE);
+		SetSendFlags(RDENT_CHANGED_MOVETYPE);
 	}
 	if (ATTR_CHANGED(size)) {
-		SetSendFlags(BASEFL_CHANGED_SIZE);
+		SetSendFlags(RDENT_CHANGED_SIZE);
 	}
 	if (ATTR_CHANGED(frame)) {
-		SetSendFlags(BASEFL_CHANGED_FRAME);
+		SetSendFlags(RDENT_CHANGED_FRAME);
 	}
 	if (ATTR_CHANGED(skin)) {
-		SetSendFlags(BASEFL_CHANGED_SKIN);
+		SetSendFlags(RDENT_CHANGED_SKIN);
 	}
 	if (ATTR_CHANGED(effects)) {
-		SetSendFlags(BASEFL_CHANGED_EFFECTS);
+		SetSendFlags(RDENT_CHANGED_EFFECTS);
 	}
 	if (ATTR_CHANGED(m_iBody)) {
-		SetSendFlags(BASEFL_CHANGED_BODY);
+		SetSendFlags(RDENT_CHANGED_BODY);
 	}
 	if (ATTR_CHANGED(scale)) {
-		SetSendFlags(BASEFL_CHANGED_SCALE);
+		SetSendFlags(RDENT_CHANGED_SCALE);
 	}
 	if (ATTR_CHANGED(velocity)) {
-		SetSendFlags(BASEFL_CHANGED_VELOCITY);
+		SetSendFlags(RDENT_CHANGED_VELOCITY);
 	}
 
 	SAVE_STATE(origin);
+	angles = Math_FixDeltaVector(angles);
 	SAVE_STATE(angles);
 	SAVE_STATE(modelindex);
 	SAVE_STATE(solid);
@@ -103,22 +116,27 @@ NSRenderableEntity::EvaluateEntity(void)
 
 #ifdef GS_RENDERFX
 	if (ATTR_CHANGED(m_iRenderMode)) {
-		SetSendFlags(BASEFL_CHANGED_RENDERMODE);
+		SetSendFlags(RDENT_CHANGED_RENDERMODE);
 	}
 	if (ATTR_CHANGED(m_iRenderFX)) {
-		SetSendFlags(BASEFL_CHANGED_RENDERMODE);
+		SetSendFlags(RDENT_CHANGED_RENDERMODE);
 	}
 
 	if (ATTR_CHANGED(m_vecRenderColor)) {
-		SetSendFlags(BASEFL_CHANGED_RENDERCOLOR);
+		SetSendFlags(RDENT_CHANGED_RENDERCOLOR);
 	}
 	if (ATTR_CHANGED(m_flRenderAmt)) {
-		SetSendFlags(BASEFL_CHANGED_RENDERAMT);
+		SetSendFlags(RDENT_CHANGED_RENDERAMT);
 	}
+	SAVE_STATE(m_iRenderMode);
+	SAVE_STATE(m_iRenderFX);
+	SAVE_STATE(m_vecRenderColor);
+	SAVE_STATE(m_flRenderAmt);
 #else
 	if (ATTR_CHANGED(alpha)) {
-		SetSendFlags(BASEFL_CHANGED_ALPHA);
+		SetSendFlags(RDENT_CHANGED_ALPHA);
 	}
+	SAVE_STATE(alpha);
 #endif
 }
 
@@ -134,38 +152,48 @@ NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
 
 	WriteByte(MSG_ENTITY, ENT_ENTITYRENDERABLE);
 
+#if 0
 	/* newly popped into the PVS, sadly this is the only hacky way to check
 	 * for this right now. convince the engine maintainer to make this more sensible */
 	if (fChanged == 0xFFFFFF) {
 		/* check for defaults. if these are predictable fields, don't even bother
 		 * networking them! you're just wasting bandwidth. */
 		if (frame == 0)
-			fChanged &= ~BASEFL_CHANGED_FRAME;
+			fChanged &= ~RDENT_CHANGED_FRAME;
 		if (skin == 0)
-			fChanged &= ~BASEFL_CHANGED_SKIN;
+			fChanged &= ~RDENT_CHANGED_SKIN;
 		if (effects == 0)
-			fChanged &= ~BASEFL_CHANGED_EFFECTS;
+			fChanged &= ~RDENT_CHANGED_EFFECTS;
 		if (m_iBody == 0)
-			fChanged &= ~BASEFL_CHANGED_BODY;
+			fChanged &= ~RDENT_CHANGED_BODY;
 		if (scale == 0.0 || scale == 1.0)
-			fChanged &= ~BASEFL_CHANGED_SCALE;
+			fChanged &= ~RDENT_CHANGED_SCALE;
-		if (origin == [0,0,0])
+		if (origin[0] == 0)
-			fChanged &= ~BASEFL_CHANGED_ORIGIN;
+			fChanged &= ~RDENT_CHANGED_ORIGIN_X;
-		if (angles == [0,0,0])
+		if (origin[1] == 0)
-			fChanged &= ~BASEFL_CHANGED_ANGLES;
+			fChanged &= ~RDENT_CHANGED_ORIGIN_Y;
+		if (origin[2] == 0)
+			fChanged &= ~RDENT_CHANGED_ORIGIN_Z;
+		if (angles[0] == 0)
+			fChanged &= ~RDENT_CHANGED_ANGLES_X;
+		if (angles[1] == 0)
+			fChanged &= ~RDENT_CHANGED_ANGLES_Y;
+		if (angles[2] == 0)
+			fChanged &= ~RDENT_CHANGED_ANGLES_Z;
 		if (velocity == [0,0,0])
-			fChanged &= ~BASEFL_CHANGED_VELOCITY;
+			fChanged &= ~RDENT_CHANGED_VELOCITY;
 		if (mins == [0,0,0] && maxs == [0,0,0])
-			fChanged &= ~BASEFL_CHANGED_SIZE;
+			fChanged &= ~RDENT_CHANGED_SIZE;
 		if (solid == SOLID_NOT)
-			fChanged &= ~BASEFL_CHANGED_SOLID;
+			fChanged &= ~RDENT_CHANGED_SOLID;
 		if (movetype == MOVETYPE_NONE)
-			fChanged &= ~BASEFL_CHANGED_MOVETYPE;
+			fChanged &= ~RDENT_CHANGED_MOVETYPE;
 #ifdef GS_RENDERFX
 		if (m_iRenderMode == RM_NORMAL)
-			fChanged &= ~BASEFL_CHANGED_RENDERMODE;
+			fChanged &= ~RDENT_CHANGED_RENDERMODE;
 #endif
 	}
+#endif
 
 	/* don't network triggers unless provoked */
 	/*if (cvar("developer") == 0 && m_iRenderMode == RM_TRIGGER)
@@ -174,28 +202,38 @@ NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
 	/* broadcast how much data is expected to be read */
 	WriteFloat(MSG_ENTITY, fChanged);
 
+	//print(sprintf("rendent send: %s %x %d\n", classname, fChanged, fChanged));
+
 	/* really trying to get our moneys worth with 23 bits of mantissa */
-	if (fChanged & BASEFL_CHANGED_ORIGIN) {
+	if (fChanged & RDENT_CHANGED_ORIGIN_X) {
 		WriteCoord(MSG_ENTITY, origin[0]);
+	}
+	if (fChanged & RDENT_CHANGED_ORIGIN_Y) {
 		WriteCoord(MSG_ENTITY, origin[1]);
+	}
+	if (fChanged & RDENT_CHANGED_ORIGIN_Z) {
 		WriteCoord(MSG_ENTITY, origin[2]);
 	}
-	if (fChanged & BASEFL_CHANGED_ANGLES) {
+	if (fChanged & RDENT_CHANGED_ANGLES_X) {
 		WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
+	}
+	if (fChanged & RDENT_CHANGED_ANGLES_Y) {
 		WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
+	}
+	if (fChanged & RDENT_CHANGED_ANGLES_Z) {
 		WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
 	}
-	if (fChanged & BASEFL_CHANGED_MODELINDEX) {
+	if (fChanged & RDENT_CHANGED_MODELINDEX) {
 		WriteShort(MSG_ENTITY, modelindex);
 		WriteByte(MSG_ENTITY, colormap);
 	}
-	if (fChanged & BASEFL_CHANGED_SOLID) {
+	if (fChanged & RDENT_CHANGED_SOLID) {
 		WriteByte(MSG_ENTITY, solid);
 	}
-	if (fChanged & BASEFL_CHANGED_MOVETYPE) {
+	if (fChanged & RDENT_CHANGED_MOVETYPE) {
 		WriteByte(MSG_ENTITY, movetype);
 	}
-	if (fChanged & BASEFL_CHANGED_SIZE) {
+	if (fChanged & RDENT_CHANGED_SIZE) {
 		WriteCoord(MSG_ENTITY, mins[0]);
 		WriteCoord(MSG_ENTITY, mins[1]);
 		WriteCoord(MSG_ENTITY, mins[2]);
@@ -203,35 +241,35 @@ NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
 		WriteCoord(MSG_ENTITY, maxs[1]);
 		WriteCoord(MSG_ENTITY, maxs[2]);
 	}
-	if (fChanged & BASEFL_CHANGED_FRAME) {
+	if (fChanged & RDENT_CHANGED_FRAME) {
 		WriteByte(MSG_ENTITY, frame);
 		WriteByte(MSG_ENTITY, frame1time);
 	}
-	if (fChanged & BASEFL_CHANGED_SKIN) {
+	if (fChanged & RDENT_CHANGED_SKIN) {
 		WriteByte(MSG_ENTITY, skin + 128);
 	}
-	if (fChanged & BASEFL_CHANGED_EFFECTS) {
+	if (fChanged & RDENT_CHANGED_EFFECTS) {
 		WriteFloat(MSG_ENTITY, effects);
 	}
-	if (fChanged & BASEFL_CHANGED_BODY) {
+	if (fChanged & RDENT_CHANGED_BODY) {
 		WriteByte(MSG_ENTITY, m_iBody);
 	}
-	if (fChanged & BASEFL_CHANGED_SCALE) {
+	if (fChanged & RDENT_CHANGED_SCALE) {
 		WriteFloat(MSG_ENTITY, scale);
 	}
-	if (fChanged & BASEFL_CHANGED_VELOCITY) {
+	if (fChanged & RDENT_CHANGED_VELOCITY) {
 		WriteFloat(MSG_ENTITY, velocity[0]);
 		WriteFloat(MSG_ENTITY, velocity[1]);
 		WriteFloat(MSG_ENTITY, velocity[2]);
 	}
 
 #ifdef GS_RENDERFX
-	if (fChanged & BASEFL_CHANGED_RENDERMODE) {
+	if (fChanged & RDENT_CHANGED_RENDERMODE) {
 		WriteByte(MSG_ENTITY, m_iRenderMode);
 		WriteByte(MSG_ENTITY, m_iRenderFX);
 	}
 
-	if (fChanged & BASEFL_CHANGED_RENDERCOLOR) {
+	if (fChanged & RDENT_CHANGED_RENDERCOLOR) {
 		WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
 		WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
 		WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
@@ -239,11 +277,11 @@ NSRenderableEntity::SendEntity(entity ePEnt, float fChanged)
 		WriteFloat(MSG_ENTITY, glowmod[1]);
 		WriteFloat(MSG_ENTITY, glowmod[2]);
 	}
-	if (fChanged & BASEFL_CHANGED_RENDERAMT) {
+	if (fChanged & RDENT_CHANGED_RENDERAMT) {
 		WriteFloat(MSG_ENTITY, m_flRenderAmt);
 	}
 #else
-	if (fChanged & BASEFL_CHANGED_ALPHA) {
+	if (fChanged & RDENT_CHANGED_ALPHA) {
 		WriteFloat(MSG_ENTITY, alpha);
 	}
 #endif
@@ -476,31 +514,39 @@ NSRenderableEntity::ReceiveEntity
 void
 NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
 {
-	if (flChanged & BASEFL_CHANGED_ORIGIN) {
+	if (flChanged & RDENT_CHANGED_ORIGIN_X) {
 		origin[0] = readcoord();
+	}
+	if (flChanged & RDENT_CHANGED_ORIGIN_Y) {
 		origin[1] = readcoord();
+	}
+	if (flChanged & RDENT_CHANGED_ORIGIN_Z) {
 		origin[2] = readcoord();
 	}
-	if (flChanged & BASEFL_CHANGED_ANGLES) {
+	if (flChanged & RDENT_CHANGED_ANGLES_X) {
 		angles[0] = readshort() / (32767 / 360);
+	}
+	if (flChanged & RDENT_CHANGED_ANGLES_Y) {
 		angles[1] = readshort() / (32767 / 360);
+	}
+	if (flChanged & RDENT_CHANGED_ANGLES_Z) {
 		angles[2] = readshort() / (32767 / 360);
 	}
-	if (flChanged & BASEFL_CHANGED_MODELINDEX) {
+	if (flChanged & RDENT_CHANGED_MODELINDEX) {
 		setmodelindex(this, readshort());
 		colormap = readbyte();
 	}
-	if (flChanged & BASEFL_CHANGED_SOLID) {
+	if (flChanged & RDENT_CHANGED_SOLID) {
 		solid = readbyte();
 	}
-	if (flChanged & BASEFL_CHANGED_MOVETYPE) {
+	if (flChanged & RDENT_CHANGED_MOVETYPE) {
 		movetype = readbyte();
 
 		if (movetype == MOVETYPE_PHYSICS) {
 			movetype = MOVETYPE_NONE;
 		}
 	}
-	if (flChanged & BASEFL_CHANGED_SIZE) {
+	if (flChanged & RDENT_CHANGED_SIZE) {
 		mins[0] = readcoord();
 		mins[1] = readcoord();
 		mins[2] = readcoord();
@@ -508,36 +554,36 @@ NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
 		maxs[1] = readcoord();
 		maxs[2] = readcoord();
 	}
-	if (flChanged & BASEFL_CHANGED_FRAME) {
+	if (flChanged & RDENT_CHANGED_FRAME) {
 		frame = readbyte();
 		frame1time =
 		frame2time = readbyte();
 	}
-	if (flChanged & BASEFL_CHANGED_SKIN) {
+	if (flChanged & RDENT_CHANGED_SKIN) {
 		skin = readbyte() - 128;
 	}
-	if (flChanged & BASEFL_CHANGED_EFFECTS) {
+	if (flChanged & RDENT_CHANGED_EFFECTS) {
 		effects = readfloat();
 	}
-	if (flChanged & BASEFL_CHANGED_BODY) {
+	if (flChanged & RDENT_CHANGED_BODY) {
 		m_iBody = readbyte();
 		setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
 	}
-	if (flChanged & BASEFL_CHANGED_SCALE) {
+	if (flChanged & RDENT_CHANGED_SCALE) {
 		scale = readfloat();
 	}
-	if (flChanged & BASEFL_CHANGED_VELOCITY) {
+	if (flChanged & RDENT_CHANGED_VELOCITY) {
 		velocity[0] = readfloat();
 		velocity[1] = readfloat();
 		velocity[2] = readfloat();
 	}
 
 #ifdef GS_RENDERFX
-	if (flChanged & BASEFL_CHANGED_RENDERMODE) {
+	if (flChanged & RDENT_CHANGED_RENDERMODE) {
 		m_iRenderMode = readbyte();
 		m_iRenderFX = readbyte();
 	}
-	if (flChanged & BASEFL_CHANGED_RENDERCOLOR) {
+	if (flChanged & RDENT_CHANGED_RENDERCOLOR) {
 		m_vecRenderColor[0] = readfloat();
 		m_vecRenderColor[1] = readfloat();
 		m_vecRenderColor[2] = readfloat();
@@ -545,11 +591,11 @@ NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
 		glowmod[1] = readfloat();
 		glowmod[2] = readfloat();
 	}
-	if (flChanged & BASEFL_CHANGED_RENDERAMT) {
+	if (flChanged & RDENT_CHANGED_RENDERAMT) {
 		m_flRenderAmt = readfloat();
 	}
 #else
-	if (flChanged & BASEFL_CHANGED_ALPHA) {
+	if (flChanged & RDENT_CHANGED_ALPHA) {
 		alpha = readfloat();
 	}
 #endif
@@ -563,7 +609,7 @@ NSRenderableEntity::ReceiveEntity(float flNew, float flChanged)
 	if (scale == 0.0)
 		scale = 1.0f;
 
-	if (flChanged & BASEFL_CHANGED_SIZE)
+	if (flChanged & RDENT_CHANGED_SIZE)
 		setsize(this, mins * scale, maxs * scale);
 
 	setorigin(this, origin);
@@ -901,3 +947,21 @@ NSRenderableEntity::NSRenderableEntity(void)
 #endif
 #endif
 }
+
+#ifdef CLIENT
+void
+NSRenderableEntity_ReadEntity(bool new)
+{
+	float fl;
+
+	NSRenderableEntity rend = (NSRenderableEntity)self;
+	if (new) {
+		spawnfunc_NSRenderableEntity();
+	}
+
+	fl = readfloat();
+	rend.ReceiveEntity(new, fl);
+
+	//print(sprintf("rendent ent update: %d %x %d %v\n", self.entnum, fl, self.origin, vlen(self.velocity)));
+}
+#endif

src/gs-entbase/shared/NSSurfacePropEntity.h

@@ -14,6 +14,30 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+enumflags
+{
+	SRFENT_CHANGED_ORIGIN,
+	SRFENT_CHANGED_ANGLES,
+	SRFENT_CHANGED_MODELINDEX,
+	SRFENT_CHANGED_SIZE,
+	SRFENT_CHANGED_FLAGS,
+	SRFENT_CHANGED_SOLID,
+	SRFENT_CHANGED_FRAME,
+	SRFENT_CHANGED_SKIN,
+	SRFENT_CHANGED_MOVETYPE,
+	SRFENT_CHANGED_EFFECTS,
+	SRFENT_CHANGED_BODY,
+	SRFENT_CHANGED_SCALE,
+	SRFENT_CHANGED_VELOCITY,
+#ifdef GS_RENDERFX
+	SRFENT_CHANGED_RENDERCOLOR,
+	SRFENT_CHANGED_RENDERAMT,
+	SRFENT_CHANGED_RENDERMODE,
+#else
+	SRFENT_CHANGED_ALPHA,
+#endif
+};
+
 class NSSurfacePropEntity:NSRenderableEntity
 {
 	float m_flBurnNext;
@@ -29,9 +53,12 @@ class NSSurfacePropEntity:NSRenderableEntity
 	virtual void(entity, string, string) Input;
 	virtual void(string, string) SpawnKey;
 	virtual void(void) ParentUpdate;
+	virtual void(void) EvaluateEntity;
+	virtual float(entity, float) SendEntity;
 #else
 	virtual float(void) predraw;
 	virtual void(void) RenderFire;
+	virtual void(float,float) ReceiveEntity;
 #endif
 
 	/* new */

src/gs-entbase/shared/NSSurfacePropEntity.qc

@@ -14,6 +14,332 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+/* networking */
+#ifdef SERVER
+void
+NSSurfacePropEntity::EvaluateEntity(void)
+{
+	if (ATTR_CHANGED(origin)) {
+		SetSendFlags(SRFENT_CHANGED_ORIGIN);
+	}
+	if (ATTR_CHANGED(angles)) {
+		SetSendFlags(SRFENT_CHANGED_ANGLES);
+	}
+	if (ATTR_CHANGED(modelindex)) {
+		SetSendFlags(SRFENT_CHANGED_MODELINDEX);
+	}
+	if (ATTR_CHANGED(solid)) {
+		SetSendFlags(SRFENT_CHANGED_SOLID);
+	}
+	if (ATTR_CHANGED(movetype)) {
+		SetSendFlags(SRFENT_CHANGED_MOVETYPE);
+	}
+	if (ATTR_CHANGED(flags)) {
+		SetSendFlags(SRFENT_CHANGED_FLAGS);
+	}
+	if (ATTR_CHANGED(size)) {
+		SetSendFlags(SRFENT_CHANGED_SIZE);
+	}
+	if (ATTR_CHANGED(frame)) {
+		SetSendFlags(SRFENT_CHANGED_FRAME);
+	}
+	if (ATTR_CHANGED(skin)) {
+		SetSendFlags(SRFENT_CHANGED_SKIN);
+	}
+	if (ATTR_CHANGED(effects)) {
+		SetSendFlags(SRFENT_CHANGED_EFFECTS);
+	}
+	if (ATTR_CHANGED(m_iBody)) {
+		SetSendFlags(SRFENT_CHANGED_BODY);
+	}
+	if (ATTR_CHANGED(scale)) {
+		SetSendFlags(SRFENT_CHANGED_SCALE);
+	}
+	if (ATTR_CHANGED(velocity)) {
+		SetSendFlags(SRFENT_CHANGED_VELOCITY);
+	}
+
+	SAVE_STATE(origin);
+	SAVE_STATE(angles);
+	SAVE_STATE(modelindex);
+	SAVE_STATE(solid);
+	SAVE_STATE(movetype);
+	SAVE_STATE(flags);
+	SAVE_STATE(size);
+	SAVE_STATE(frame);
+	SAVE_STATE(skin);
+	SAVE_STATE(effects);
+	SAVE_STATE(m_iBody);
+	SAVE_STATE(scale);
+	SAVE_STATE(velocity);
+
+#ifdef GS_RENDERFX
+	if (ATTR_CHANGED(m_iRenderMode)) {
+		SetSendFlags(SRFENT_CHANGED_RENDERMODE);
+	}
+	if (ATTR_CHANGED(m_iRenderFX)) {
+		SetSendFlags(SRFENT_CHANGED_RENDERMODE);
+	}
+
+	if (ATTR_CHANGED(m_vecRenderColor)) {
+		SetSendFlags(SRFENT_CHANGED_RENDERCOLOR);
+	}
+	if (ATTR_CHANGED(m_flRenderAmt)) {
+		SetSendFlags(SRFENT_CHANGED_RENDERAMT);
+	}
+	SAVE_STATE(m_iRenderMode);
+	SAVE_STATE(m_iRenderFX);
+	SAVE_STATE(m_vecRenderColor);
+	SAVE_STATE(m_flRenderAmt);
+#else
+	if (ATTR_CHANGED(alpha)) {
+		SetSendFlags(SRFENT_CHANGED_ALPHA);
+	}
+	SAVE_STATE(alpha);
+#endif
+}
+
+/* Make sure StartFrame calls this */
+float
+NSSurfacePropEntity::SendEntity(entity ePEnt, float fChanged)
+{
+	if (!modelindex)
+		return (0);
+
+	if (clienttype(ePEnt) != CLIENTTYPE_REAL)
+		return (0);
+
+	WriteByte(MSG_ENTITY, ENT_SURFPROP);
+
+	//print(sprintf("%s %x\n", classname, fChanged));
+
+#if 0
+	/* newly popped into the PVS, sadly this is the only hacky way to check
+	 * for this right now. convince the engine maintainer to make this more sensible */
+	if (fChanged == 0xFFFFFF) {
+		/* check for defaults. if these are predictable fields, don't even bother
+		 * networking them! you're just wasting bandwidth. */
+		if (frame == 0)
+			fChanged &= ~SRFENT_CHANGED_FRAME;
+		if (skin == 0)
+			fChanged &= ~SRFENT_CHANGED_SKIN;
+		if (effects == 0)
+			fChanged &= ~SRFENT_CHANGED_EFFECTS;
+		if (m_iBody == 0)
+			fChanged &= ~SRFENT_CHANGED_BODY;
+		if (scale == 0.0 || scale == 1.0)
+			fChanged &= ~SRFENT_CHANGED_SCALE;
+		if (origin == [0,0,0])
+			fChanged &= ~SRFENT_CHANGED_ORIGIN;
+		if (angles == [0,0,0])
+			fChanged &= ~SRFENT_CHANGED_ANGLES;
+		if (velocity == [0,0,0])
+			fChanged &= ~SRFENT_CHANGED_VELOCITY;
+		if (mins == [0,0,0] && maxs == [0,0,0])
+			fChanged &= ~SRFENT_CHANGED_SIZE;
+		if (solid == SOLID_NOT)
+			fChanged &= ~SRFENT_CHANGED_SOLID;
+		if (movetype == MOVETYPE_NONE)
+			fChanged &= ~SRFENT_CHANGED_MOVETYPE;
+#ifdef GS_RENDERFX
+		if (m_iRenderMode == RM_NORMAL)
+			fChanged &= ~SRFENT_CHANGED_RENDERMODE;
+#endif
+	}
+#endif
+
+	/* don't network triggers unless provoked */
+	/*if (cvar("developer") == 0 && m_iRenderMode == RM_TRIGGER)
+		return (0);*/
+
+	/* broadcast how much data is expected to be read */
+	WriteFloat(MSG_ENTITY, fChanged);
+
+	/* really trying to get our moneys worth with 23 bits of mantissa */
+	if (fChanged & SRFENT_CHANGED_ORIGIN) {
+		WriteCoord(MSG_ENTITY, origin[0]);
+		WriteCoord(MSG_ENTITY, origin[1]);
+		WriteCoord(MSG_ENTITY, origin[2]);
+	}
+	if (fChanged & SRFENT_CHANGED_ANGLES) {
+		WriteShort(MSG_ENTITY, angles[0] * 32767 / 360);
+		WriteShort(MSG_ENTITY, angles[1] * 32767 / 360);
+		WriteShort(MSG_ENTITY, angles[2] * 32767 / 360);
+	}
+	if (fChanged & SRFENT_CHANGED_MODELINDEX) {
+		WriteShort(MSG_ENTITY, modelindex);
+		WriteByte(MSG_ENTITY, colormap);
+	}
+	if (fChanged & SRFENT_CHANGED_SOLID) {
+		WriteByte(MSG_ENTITY, solid);
+	}
+	if (fChanged & SRFENT_CHANGED_MOVETYPE) {
+		WriteByte(MSG_ENTITY, movetype);
+	}
+	if (fChanged & SRFENT_CHANGED_FLAGS) {
+		WriteFloat(MSG_ENTITY, flags);
+	}
+	if (fChanged & SRFENT_CHANGED_SIZE) {
+		WriteCoord(MSG_ENTITY, mins[0]);
+		WriteCoord(MSG_ENTITY, mins[1]);
+		WriteCoord(MSG_ENTITY, mins[2]);
+		WriteCoord(MSG_ENTITY, maxs[0]);
+		WriteCoord(MSG_ENTITY, maxs[1]);
+		WriteCoord(MSG_ENTITY, maxs[2]);
+	}
+	if (fChanged & SRFENT_CHANGED_FRAME) {
+		WriteByte(MSG_ENTITY, frame);
+		WriteByte(MSG_ENTITY, frame1time);
+	}
+	if (fChanged & SRFENT_CHANGED_SKIN) {
+		WriteByte(MSG_ENTITY, skin + 128);
+	}
+	if (fChanged & SRFENT_CHANGED_EFFECTS) {
+		WriteFloat(MSG_ENTITY, effects);
+	}
+	if (fChanged & SRFENT_CHANGED_BODY) {
+		WriteByte(MSG_ENTITY, m_iBody);
+	}
+	if (fChanged & SRFENT_CHANGED_SCALE) {
+		WriteFloat(MSG_ENTITY, scale);
+	}
+	if (fChanged & SRFENT_CHANGED_VELOCITY) {
+		WriteFloat(MSG_ENTITY, velocity[0]);
+		WriteFloat(MSG_ENTITY, velocity[1]);
+		WriteFloat(MSG_ENTITY, velocity[2]);
+	}
+
+#ifdef GS_RENDERFX
+	if (fChanged & SRFENT_CHANGED_RENDERMODE) {
+		WriteByte(MSG_ENTITY, m_iRenderMode);
+		WriteByte(MSG_ENTITY, m_iRenderFX);
+	}
+
+	if (fChanged & SRFENT_CHANGED_RENDERCOLOR) {
+		WriteFloat(MSG_ENTITY, m_vecRenderColor[0]);
+		WriteFloat(MSG_ENTITY, m_vecRenderColor[1]);
+		WriteFloat(MSG_ENTITY, m_vecRenderColor[2]);
+		WriteFloat(MSG_ENTITY, glowmod[0]);
+		WriteFloat(MSG_ENTITY, glowmod[1]);
+		WriteFloat(MSG_ENTITY, glowmod[2]);
+	}
+	if (fChanged & SRFENT_CHANGED_RENDERAMT) {
+		WriteFloat(MSG_ENTITY, m_flRenderAmt);
+	}
+#else
+	if (fChanged & SRFENT_CHANGED_ALPHA) {
+		WriteFloat(MSG_ENTITY, alpha);
+	}
+#endif
+
+	return (1);
+}
+#else
+/*
+============
+NSSurfacePropEntity::ReceiveEntity
+============
+*/
+void
+NSSurfacePropEntity::ReceiveEntity(float flNew, float flChanged)
+{
+	if (flChanged & SRFENT_CHANGED_ORIGIN) {
+		origin[0] = readcoord();
+		origin[1] = readcoord();
+		origin[2] = readcoord();
+	}
+	if (flChanged & SRFENT_CHANGED_ANGLES) {
+		angles[0] = readshort() / (32767 / 360);
+		angles[1] = readshort() / (32767 / 360);
+		angles[2] = readshort() / (32767 / 360);
+	}
+	if (flChanged & SRFENT_CHANGED_MODELINDEX) {
+		setmodelindex(this, readshort());
+		colormap = readbyte();
+	}
+	if (flChanged & SRFENT_CHANGED_SOLID) {
+		solid = readbyte();
+	}
+	if (flChanged & SRFENT_CHANGED_MOVETYPE) {
+		movetype = readbyte();
+
+		if (movetype == MOVETYPE_PHYSICS) {
+			movetype = MOVETYPE_NONE;
+		}
+	}
+	if (flChanged & SRFENT_CHANGED_FLAGS) {
+		flags = readfloat();
+	}
+	if (flChanged & SRFENT_CHANGED_SIZE) {
+		mins[0] = readcoord();
+		mins[1] = readcoord();
+		mins[2] = readcoord();
+		maxs[0] = readcoord();
+		maxs[1] = readcoord();
+		maxs[2] = readcoord();
+	}
+	if (flChanged & SRFENT_CHANGED_FRAME) {
+		frame = readbyte();
+		frame1time =
+		frame2time = readbyte();
+	}
+	if (flChanged & SRFENT_CHANGED_SKIN) {
+		skin = readbyte() - 128;
+	}
+	if (flChanged & SRFENT_CHANGED_EFFECTS) {
+		effects = readfloat();
+	}
+	if (flChanged & SRFENT_CHANGED_BODY) {
+		m_iBody = readbyte();
+		setcustomskin(this, "", sprintf("geomset 0 %i\ngeomset 1 %i\n", m_iBody, m_iBody));
+	}
+	if (flChanged & SRFENT_CHANGED_SCALE) {
+		scale = readfloat();
+	}
+	if (flChanged & SRFENT_CHANGED_VELOCITY) {
+		velocity[0] = readfloat();
+		velocity[1] = readfloat();
+		velocity[2] = readfloat();
+	}
+
+#ifdef GS_RENDERFX
+	if (flChanged & SRFENT_CHANGED_RENDERMODE) {
+		m_iRenderMode = readbyte();
+		m_iRenderFX = readbyte();
+	}
+	if (flChanged & SRFENT_CHANGED_RENDERCOLOR) {
+		m_vecRenderColor[0] = readfloat();
+		m_vecRenderColor[1] = readfloat();
+		m_vecRenderColor[2] = readfloat();
+		glowmod[0] = readfloat();
+		glowmod[1] = readfloat();
+		glowmod[2] = readfloat();
+	}
+	if (flChanged & SRFENT_CHANGED_RENDERAMT) {
+		m_flRenderAmt = readfloat();
+	}
+#else
+	if (flChanged & SRFENT_CHANGED_ALPHA) {
+		alpha = readfloat();
+	}
+#endif
+
+	if (modelindex) {
+		drawmask = MASK_ENGINE;
+	} else {
+		drawmask = 0;
+	}
+
+	if (scale == 0.0)
+		scale = 1.0f;
+
+	if (flChanged & SRFENT_CHANGED_SIZE)
+		setsize(this, mins * scale, maxs * scale);
+
+	setorigin(this, origin);
+}
+#endif
+
 #ifdef SERVER
 void
 NSSurfacePropEntity::SetTakedamage(float type)
@@ -360,3 +686,17 @@ NSSurfacePropEntity::NSSurfacePropEntity(void)
 	m_strOnBreak = CreateOutput(m_strOnBreak);
 #endif
 }
+
+#ifdef CLIENT
+void
+NSSurfacePropEntity_ReadEntity(bool new)
+{
+	float fl;
+	NSSurfacePropEntity rend = (NSSurfacePropEntity)self;
+	if (new) {
+		spawnfunc_NSSurfacePropEntity();
+	}
+	fl = readfloat();
+	rend.ReceiveEntity(new, fl);
+}
+#endif

src/shared/entities.h

@@ -20,6 +20,7 @@ enum
 	ENT_NONE,
 	ENT_ENTITY,
 	ENT_ENTITYRENDERABLE,
+	ENT_SURFPROP,
 	ENT_PHYSICS,
 	ENT_MONSTER,
 	ENT_TALKMONSTER,