vera/nuclide
4
0
Fork 0
Code Issues 32 Pull requests Projects Releases Packages Activity

Networking improvements to NSEntity, NSRenderableEntity and NSSurfacePropEntity

Browse source
This commit is contained in:
Marco Cawthorne 2022-04-20 14:29:37 -07:00
parent 8781494822
commit af6412e283
Signed by: eukara
GPG key ID: C196CD8BA993248A
9 changed files with 556 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/client/entities.qc
View file

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

24
src/gs-entbase/baseentity.h
View file

@ -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;

25
src/gs-entbase/shared/NSEntity.h
View file

@ -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;

1
src/gs-entbase/shared/NSEntity.qc
View file

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

30
src/gs-entbase/shared/NSRenderableEntity.h
View file

@ -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;

196
src/gs-entbase/shared/NSRenderableEntity.qc
View file

@ -51,44 +51,57 @@ NSRenderableEntity::MakeStatic(void)
void
NSRenderableEntity::EvaluateEntity(void)
{
if (ATTR_CHANGED(origin)) {
SetSendFlags(BASEFL_CHANGED_ORIGIN);
if (VEC_CHANGED(origin,0)) {
SetSendFlags(RDENT_CHANGED_ORIGIN_X);
}
if (ATTR_CHANGED(angles)) {
SetSendFlags(BASEFL_CHANGED_ANGLES);
if (VEC_CHANGED(origin,1)) {
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;
if (origin == [0,0,0])
fChanged &= ~BASEFL_CHANGED_ORIGIN;
if (angles == [0,0,0])
fChanged &= ~BASEFL_CHANGED_ANGLES;
fChanged &= ~RDENT_CHANGED_SCALE;
if (origin[0] == 0)
fChanged &= ~RDENT_CHANGED_ORIGIN_X;
if (origin[1] == 0)
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

27
src/gs-entbase/shared/NSSurfacePropEntity.h
View file

@ -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 */

340
src/gs-entbase/shared/NSSurfacePropEntity.qc
View file

@ -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

1
src/shared/entities.h
View file

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