#ifndef PROTOCOL_H
#define PROTOCOL_H
-#define PROTOCOL_VERSION 15
-#define DPPROTOCOL_VERSION1 96
-#define DPPROTOCOL_VERSION2 97
+#define PROTOCOL_QUAKE 15
+#define PROTOCOL_NEHAHRAMOVIE 250
+#define PROTOCOL_DARKPLACES1 96
+#define PROTOCOL_DARKPLACES2 97
// LordHavoc: I think the 96-99 range was going to run out too soon...
// so here I jump to 3500
-#define DPPROTOCOL_VERSION3 3500
-// partial entity updates, changed entity origin updates back to quake style
-// (RENDER_LOWPRECISION on by default, but the precision was changed from
-// integer to 1/8th unit like quake)
-#define DPPROTOCOL_VERSION4 3501
+#define PROTOCOL_DARKPLACES3 3500
+#define PROTOCOL_DARKPLACES4 3501
+#define PROTOCOL_DARKPLACES5 3502
// model effects
#define EF_ROCKET 1 // leave a trail
#define EF_STEP 0x80000000 // internal client use only - present on MOVETYPE_STEP entities, not QC accessible (too many bits)
+// flags for the pflags field of entities
+#define PFLAGS_NOSHADOW 1
+#define PFLAGS_CORONA 2
+#define PFLAGS_FULLDYNAMIC 128 // must be set or the light fields are ignored
+
// if the high bit of the servercmd is set, the low bits are fast update flags:
#define U_MOREBITS (1<<0)
#define U_ORIGIN1 (1<<1)
#define U_ALPHA (1<<17) // 1 byte, 0.0-1.0 maps to 0-255, not sent if exactly 1, and the entity is not sent if <=0 unless it has effects (model effects are checked as well)
#define U_SCALE (1<<18) // 1 byte, scale / 16 positive, not sent if 1.0
#define U_EFFECTS2 (1<<19) // 1 byte, this is .effects & 0xFF00 (second byte)
-#define U_GLOWSIZE (1<<20) // 1 byte, encoding is float/8.0, signed (negative is darklight), not sent if 0
+#define U_GLOWSIZE (1<<20) // 1 byte, encoding is float/4.0, unsigned, not sent if 0
#define U_GLOWCOLOR (1<<21) // 1 byte, palette index, default is 254 (white), this IS used for darklight (allowing colored darklight), however the particles from a darklight are always black, not sent if default value (even if glowsize or glowtrail is set)
// LordHavoc: colormod feature has been removed, because no one used it
#define U_COLORMOD (1<<22) // 1 byte, 3 bit red, 3 bit green, 2 bit blue, this lets you tint an object artifically, so you could make a red rocket, or a blue fiend...
#define TE_SUPERSPIKEQUAD 59 // [vector] origin
// LordHavoc: block2 - 70-80
#define TE_EXPLOSIONQUAD 70 // [vector] origin
-#define TE_BLOOD2 71 // [vector] origin
+#define TE_UNUSED1 71 // unused
#define TE_SMALLFLASH 72 // [vector] origin
#define TE_CUSTOMFLASH 73 // [vector] origin [byte] radius / 8 - 1 [byte] lifetime / 256 - 1 [byte] red [byte] green [byte] blue
#define TE_FLAMEJET 74 // [vector] origin [vector] velocity [byte] count
#define RENDER_LOWPRECISION 16 // send as low precision coordinates to save bandwidth
#define RENDER_COLORMAPPED 32
#define RENDER_SHADOW 64 // cast shadow
+#define RENDER_LIGHT 128 // receive light
typedef struct
{
unsigned short modelindex;
unsigned short frame;
unsigned short effects;
+ unsigned short tagentity;
+ unsigned short specialvisibilityradius; // larger if it has effects/light
+ unsigned short viewmodelforclient;
+ unsigned short exteriormodelforclient;
+ unsigned short nodrawtoclient;
+ unsigned short drawonlytoclient;
+ unsigned short light[4]; // color*256 (0.00 to almost 64.00), and radius*1
+ qbyte lightstyle;
+ qbyte lightpflags;
qbyte colormap;
- qbyte skin;
+ qbyte skin; // also chooses cubemap for rtlights if there is no model
qbyte alpha;
qbyte scale;
qbyte glowsize;
qbyte glowcolor;
qbyte flags;
+ qbyte tagindex;
+ // padding to a multiple of 8 bytes (to align the double time)
+ qbyte unused[6];
}
entity_state_t;
+/*
+PROTOCOL_DARKPLACES3
+server updates entities according to some (unmentioned) scheme.
+
+a frame consists of all visible entities, some of which are up to date,
+often some are not up to date.
+
+these entities are stored in a range (firstentity/endentity) of structs in the
+entitydata[] buffer.
+
+to make a commit the server performs these steps:
+1. duplicate oldest frame in database (this is the baseline) as new frame, and
+ write frame numbers (oldest frame's number, new frame's number) and eye
+ location to network packet (eye location is obsolete and will be removed in
+ future revisions)
+2. write an entity change to packet and modify new frame accordingly
+ (this repeats until packet is sufficiently full or new frame is complete)
+3. write terminator (0xFFFF) to network packet
+ (FIXME: this terminator value conflicts with MAX_EDICTS 32768...)
+
+to read a commit the client performs these steps:
+1. reads frame numbers from packet and duplicates baseline frame as new frame,
+ also reads eye location but does nothing with it (obsolete).
+2. delete frames older than the baseline which was used
+3. read entity changes from packet until terminator (0xFFFF) is encountered,
+ each change is applied to entity frame.
+4. sends ack framenumber to server as part of input packet
+
+if server receives ack message in put packet it performs these steps:
+1. remove all older frames from database.
+*/
+
+/*
+PROTOCOL_DARKPLACES4
+a frame consists of some visible entities in a range (this is stored as start and end, note that end may be less than start if it wrapped).
+
+these entities are stored in a range (firstentity/endentity) of structs in the entitydata[] buffer.
+
+to make a commit the server performs these steps:
+1. build an entity_frame_t using appropriate functions, containing (some of) the visible entities, this is passed to the Write function to send it.
+
+This documention is unfinished!
+the Write function performs these steps:
+1. check if entity frame is larger than MAX_ENTITYFRAME or is larger than available space in database, if so the baseline is defaults, otherwise it is the current baseline of the database.
+2. write differences of an entity compared to selected baseline.
+3. add entity to entity update in database.
+4. if there are more entities to write and packet is not full, go back to step 2.
+5. write terminator (0xFFFF) as entity number.
+6. return.
+
+
+
+
+
+server updates entities in looping ranges, a frame consists of a range of visible entities (not always all visible entities),
+*/
+
typedef struct
{
double time;
double time;
int framenum;
int numentities;
+ int firstentitynum;
+ int lastentitynum;
vec3_t eye;
entity_state_t entitydata[MAX_ENTITY_DATABASE];
}
entity_frame_t;
-/*
-DPPROTOCOL_VERSION4
-server only updates entities according to some (unmentioned) scheme.
-
-a commit consists of all entities changed at server's discretion,
-these entities are stored in a range (start/count) of structs in the
-commitentity[] buffer.
-
-when a commit is confirmed, range_count entity states beginning at
-commitentity[range_start] (this may wrap!) are read and copied into
-currententity according to their .number field, and the commit (and
-any older commits) are deleted.
-*/
-
-// DPPROTOCOL_VERSION4
-#define MAX_ENTITIES_PER_FRAME 1024
-
-// DPPROTOCOL_VERSION4
-typedef struct
-{
- // time of frame
- double time;
- // number of frame
- int framenum;
-
- // range of commmitentity[] items owned by this frame (this may wrap!)
- int range_start;
- int range_count;
-}
-entity_commitframe4_t;
-
-// DPPROTOCOL_VERSION4
-typedef struct
-{
- // note: each frame contains a limited number of entities, so in
- // situations with a high maximum data rate AND large number of entities,
- // updates may be partial despite a high data rate.
-
- // time of current frame
- double time;
- // number of current frame
- int framenum;
-
- // number of frames waiting to be committed to database
- int numframes;
-
- // current entity states
- entity_state_t entity[MAX_EDICTS];
-
- // unconfirmed entity states
- entity_state_t commitentity[MAX_EDICTS];
-
- // frame updates that have not yet been committed to entity
- entity_commitframe4_t commitframes[MAX_ENTITY_HISTORY];
-}
-entity_database4_t;
-
// LordHavoc: these are in approximately sorted order, according to cost and
// likelyhood of being used for numerous objects in a frame
#define E_EFFECTS2 (1<<18)
#define E_GLOWSIZE (1<<19)
#define E_GLOWCOLOR (1<<20)
-#define E_UNUSED1 (1<<21)
-#define E_UNUSED2 (1<<22)
+#define E_LIGHT (1<<21)
+#define E_LIGHTPFLAGS (1<<22)
#define E_EXTEND3 (1<<23)
#define E_SOUND1 (1<<24)
#define E_SOUNDVOL (1<<25)
#define E_SOUNDATTEN (1<<26)
-#define E_UNUSED4 (1<<27)
-#define E_UNUSED5 (1<<28)
+#define E_TAGATTACHMENT (1<<27)
+#define E_LIGHTSTYLE (1<<28)
#define E_UNUSED6 (1<<29)
#define E_UNUSED7 (1<<30)
#define E_EXTEND4 (1<<31)
+// clears a state to baseline values
void ClearStateToDefault(entity_state_t *s);
+// used by some of the DP protocols
+void EntityState_Write(entity_state_t *ent, sizebuf_t *msg, entity_state_t *delta);
// (server) clears the database to contain no frames (thus delta compression
// compresses against nothing)
// (server and client) removes frames older than 'frame' from database
void EntityFrame_AckFrame(entity_database_t *d, int frame);
// (server) clears frame, to prepare for adding entities
-void EntityFrame_Clear(entity_frame_t *f, vec3_t eye);
-// (server) allocates an entity slot in frame, returns NULL if full
-entity_state_t *EntityFrame_NewEntity(entity_frame_t *f, int number);
+void EntityFrame_Clear(entity_frame_t *f, vec3_t eye, int framenum);
+// (server) adds an entity to frame
+void EntityFrame_AddEntity(entity_frame_t *f, entity_state_t *s);
// (server and client) reads a frame from the database
void EntityFrame_FetchFrame(entity_database_t *d, int framenum, entity_frame_t *f);
// (server and client) adds a entity_frame to the database, for future
// (client) returns the frame number of the most recent frame recieved
int EntityFrame_MostRecentlyRecievedFrameNum(entity_database_t *d);
+typedef struct entity_database4_commit_s
+{
+ // frame number this commit represents
+ int framenum;
+ // number of entities in entity[] array
+ int numentities;
+ // maximum number of entities in entity[] array (dynamic resizing)
+ int maxentities;
+ entity_state_t *entity;
+}
+entity_database4_commit_t;
+
+typedef struct entity_database4_s
+{
+ // what mempool to use for allocations
+ mempool_t *mempool;
+ // reference frame
+ int referenceframenum;
+ // reference entities array is resized according to demand
+ int maxreferenceentities;
+ // array of states for entities, these are indexable by their entity number (yes there are gaps)
+ entity_state_t *referenceentity;
+ // commits waiting to be applied to the reference database when confirmed
+ // (commit[i]->numentities == 0 means it is empty)
+ entity_database4_commit_t commit[MAX_ENTITY_HISTORY];
+ // (server only) the current commit being worked on
+ entity_database4_commit_t *currentcommit;
+ // (server only) if a commit won't fit entirely, continue where it left
+ // off next frame
+ int currententitynumber;
+ // (client only) most recently received frame number to be sent in next
+ // input update
+ int ackframenum;
+}
+entity_database4_t;
+
+// should-be-private functions that aren't
+entity_state_t *EntityFrame4_GetReferenceEntity(entity_database4_t *d, int number);
+void EntityFrame4_AddCommitEntity(entity_database4_t *d, entity_state_t *s);
+
+// allocate a database
+entity_database4_t *EntityFrame4_AllocDatabase(mempool_t *pool);
+// free a database
+void EntityFrame4_FreeDatabase(entity_database4_t *d);
+// reset a database (resets compression but does not reallocate anything)
+void EntityFrame4_ResetDatabase(entity_database4_t *d);
+// updates database to account for a frame-received acknowledgment
+int EntityFrame4_AckFrame(entity_database4_t *d, int framenum);
+
+// write an entity in the frame
+// returns false if full
+int EntityFrame4_SV_WriteFrame_Entity(entity_database4_t *d, sizebuf_t *msg, int maxbytes, entity_state_t *s);
+// reads a frame from the network stream
+void EntityFrame4_CL_ReadFrame(entity_database4_t *d);
-// (server and client) clears the database to contain blank entities and no
-// commits (thus delta compression compresses against nothing)
-void EntityFrame4_ClearDatabase(entity_database4_t *d);
-// (server and client) applies commit to database and removes it (and older)
-void EntityFrame4_Commit_Ack(entity_database4_t *d, int frame);
-// (server) prepares for sending entities
-void EntityFrame4_Commit_Write_Begin(entity_database4_t *d, int frame, sizebuf_t *msg);
-// (server) sends an entity and adds to current commit (may delete old
-// commits to make room), returns success if there is room left in the packet
-// (according to maxbytes), otherwise false (end commit)
-int EntityFrame4_Commit_Write_Entity(entity_database4_t *d, entity_state_t *s, sizebuf_t *msg, int maxbytes);
-// (server) ends commit
-void EntityFrame4_Commit_Write_End(entity_database4_t *d, sizebuf_t *msg);
-// (client) begins parsing of a commit from the network stream
-void EntityFrame4_Commit_Read_Begin(entity_database4_t *d);
-// (client) parses a commit entity from the network stream (NULL == end)
-entity_state_t *EntityFrame4_Commit_Read_Entity(entity_database4_t *d);
+extern cvar_t developer_networkentities;
#endif
projects / xonotic / darkplaces.git / blobdiff