tenebrae/tenebrae2
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

CM_* methods take a model as parameter (to keep client & server separated)

Browse source
This commit is contained in:
cholleme 2003-02-15 17:52:07 +00:00
parent 12dc8b4ee8
commit 69b03db688
4 changed files with 54 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
pr_cmds.c
View file

@ -1870,7 +1870,7 @@ void PF_SetAreaPortalState(void)
int area1 = G_FLOAT(OFS_PARM0); int area1 = G_FLOAT(OFS_PARM0);
int area2 = G_FLOAT(OFS_PARM1); int area2 = G_FLOAT(OFS_PARM1);
int open = G_FLOAT(OFS_PARM2); int open = G_FLOAT(OFS_PARM2);
CM_SetAreaPortalState(area1,area2,open); CM_SetAreaPortalState(sv.worldmodel, area1,area2,open);
} }

2
sv_main.c
View file

@ -444,7 +444,7 @@ void SV_WriteEntitiesToClient (edict_t *clent, sizebuf_t *msg)
//find the client's Area Portal state //find the client's Area Portal state
clientleaf = Mod_PointInLeaf(org, sv.worldmodel); clientleaf = Mod_PointInLeaf(org, sv.worldmodel);
areabytes = CM_WriteAreaBits(areabits, clientleaf->area); areabytes = CM_WriteAreaBits(sv.worldmodel, areabits, clientleaf->area);
// send over all entities (excpet the client) that touch the pvs // send over all entities (excpet the client) that touch the pvs
ent = NEXT_EDICT(sv.edicts); ent = NEXT_EDICT(sv.edicts);

94
sv_q3support.c
View file

@ -28,7 +28,7 @@ mplane_t *box_planes;
int box_firstbrush; int box_firstbrush;
mbrush_t *box_brush; mbrush_t *box_brush;
#define M sv.worldmodel //#define M sv.worldmodel
//timestamp variables //timestamp variables
int c_pointcontents = 0; int c_pointcontents = 0;
@ -44,7 +44,7 @@ Set up the planes and nodes so that the six floats of a bounding box
can just be stored out and get a proper clipping hull structure. can just be stored out and get a proper clipping hull structure.
=================== ===================
*/ */
void CM_InitBoxHull (void) void CM_InitBoxHull (model_t *M)
{ {
int i; int i;
int side; int side;
@ -65,7 +65,7 @@ void CM_InitBoxHull (void)
// brush sides // brush sides
s = &M->brushsides[M->numbrushsides+i]; s = &M->brushsides[M->numbrushsides+i];
s->plane = M->planes + (M->numplanes+i*2+side); s->plane = M->planes + (M->numplanes+i*2+side);
s->texture = NULL; s->shader = NULL;
// planes // planes
p = &box_planes[i*2]; p = &box_planes[i*2];
@ -139,7 +139,7 @@ CM_PointLeafnum_r
================== ==================
*/ */
int CM_PointLeafnum_r (vec3_t p, int num) int CM_PointLeafnum_r (model_t *M, vec3_t p, int num)
{ {
float d; float d;
mnode_t *node; mnode_t *node;
@ -165,11 +165,11 @@ int CM_PointLeafnum_r (vec3_t p, int num)
return -1 - num; return -1 - num;
} }
int CM_PointLeafnum (vec3_t p) int CM_PointLeafnum (model_t *M, vec3_t p)
{ {
if (!M->numplanes) if (!M->numplanes)
return 0; // sound may call this without map loaded return 0; // sound may call this without map loaded
return CM_PointLeafnum_r (p, 0); return CM_PointLeafnum_r (M, p, 0);
} }
@ -186,7 +186,7 @@ int *leaf_list;
float *leaf_mins, *leaf_maxs; float *leaf_mins, *leaf_maxs;
int leaf_topnode; int leaf_topnode;
void CM_BoxLeafnums_r (int nodenum) void CM_BoxLeafnums_r (model_t *M, int nodenum)
{ {
mplane_t *plane; mplane_t *plane;
mnode_t *node; mnode_t *node;
@ -217,14 +217,14 @@ void CM_BoxLeafnums_r (int nodenum)
{ // go down both { // go down both
if (leaf_topnode == -1) if (leaf_topnode == -1)
leaf_topnode = nodenum; leaf_topnode = nodenum;
CM_BoxLeafnums_r (node->ichildren[0]); CM_BoxLeafnums_r (M, node->ichildren[0]);
nodenum = node->ichildren[1]; nodenum = node->ichildren[1];
} }
} }
} }
int CM_BoxLeafnums_headnode (vec3_t mins, vec3_t maxs, int *list, int listsize, int headnode, int *topnode) int CM_BoxLeafnums_headnode (model_t *M, vec3_t mins, vec3_t maxs, int *list, int listsize, int headnode, int *topnode)
{ {
leaf_list = list; leaf_list = list;
leaf_count = 0; leaf_count = 0;
@ -234,7 +234,7 @@ int CM_BoxLeafnums_headnode (vec3_t mins, vec3_t maxs, int *list, int listsize,
leaf_topnode = -1; leaf_topnode = -1;
CM_BoxLeafnums_r (headnode); CM_BoxLeafnums_r (M, headnode);
if (topnode) if (topnode)
*topnode = leaf_topnode; *topnode = leaf_topnode;
@ -242,9 +242,9 @@ int CM_BoxLeafnums_headnode (vec3_t mins, vec3_t maxs, int *list, int listsize,
return leaf_count; return leaf_count;
} }
int CM_BoxLeafnums (vec3_t mins, vec3_t maxs, int *list, int listsize, int *topnode) int CM_BoxLeafnums (model_t *M,vec3_t mins, vec3_t maxs, int *list, int listsize, int *topnode)
{ {
return CM_BoxLeafnums_headnode (mins, maxs, list, return CM_BoxLeafnums_headnode (M,mins, maxs, list,
listsize, 0 /*headnode??*/, topnode); listsize, 0 /*headnode??*/, topnode);
} }
@ -256,7 +256,7 @@ CM_PointContents
================== ==================
*/ */
int CM_PointContents (vec3_t p, int headnode) int CM_PointContents (model_t *M, vec3_t p, int headnode)
{ {
int l, contents, i, j; int l, contents, i, j;
mleaf_t *leaf; mleaf_t *leaf;
@ -266,7 +266,7 @@ int CM_PointContents (vec3_t p, int headnode)
if (!M->numnodes) // map not loaded if (!M->numnodes) // map not loaded
return 0; return 0;
l = CM_PointLeafnum_r (p, 0 /*headnode*/); l = CM_PointLeafnum_r (M, p, 0 /*headnode*/);
//PENTA: Based on qfusion contents soucre //PENTA: Based on qfusion contents soucre
leaf = &M->leafs[l]; leaf = &M->leafs[l];
@ -307,7 +307,7 @@ Handles offseting and rotation of the end points for moving and
rotating entities rotating entities
================== ==================
*/ */
int CM_TransformedPointContents (vec3_t p, int headnode, vec3_t origin, vec3_t angles) int CM_TransformedPointContents (model_t *M, vec3_t p, int headnode, vec3_t origin, vec3_t angles)
{ {
vec3_t p_l; vec3_t p_l;
vec3_t temp; vec3_t temp;
@ -328,7 +328,7 @@ int CM_TransformedPointContents (vec3_t p, int headnode, vec3_t origin, vec3_t a
p_l[2] = DotProduct (temp, up); p_l[2] = DotProduct (temp, up);
} }
l = CM_PointLeafnum_r (p_l, headnode); l = CM_PointLeafnum_r (M, p_l, headnode);
return M->leafs[l].contents; return M->leafs[l].contents;
} }
@ -358,7 +358,7 @@ qboolean trace_ispoint; // optimized case
CM_ClipBoxToBrush CM_ClipBoxToBrush
================ ================
*/ */
void CM_ClipBoxToBrush (vec3_t mins, vec3_t maxs, vec3_t p1, vec3_t p2, void CM_ClipBoxToBrush (model_t *M, vec3_t mins, vec3_t maxs, vec3_t p1, vec3_t p2,
trace_t *trace, mbrush_t *brush) trace_t *trace, mbrush_t *brush)
{ {
int i, j; int i, j;
@ -474,7 +474,7 @@ void CM_ClipBoxToBrush (vec3_t mins, vec3_t maxs, vec3_t p1, vec3_t p2,
CM_TestBoxInBrush CM_TestBoxInBrush
================ ================
*/ */
void CM_TestBoxInBrush (vec3_t mins, vec3_t maxs, vec3_t p1, void CM_TestBoxInBrush (model_t *M, vec3_t mins, vec3_t maxs, vec3_t p1,
trace_t *trace, mbrush_t *brush) trace_t *trace, mbrush_t *brush)
{ {
int i, j; int i, j;
@ -531,7 +531,7 @@ void CM_TestBoxInBrush (vec3_t mins, vec3_t maxs, vec3_t p1,
CM_TraceToLeaf CM_TraceToLeaf
================ ================
*/ */
void CM_TraceToLeaf (int leafnum) void CM_TraceToLeaf (model_t *M, int leafnum)
{ {
int k; int k;
int brushnum; int brushnum;
@ -568,7 +568,7 @@ void CM_TraceToLeaf (int leafnum)
if ( !(b->contents & trace_contents)) if ( !(b->contents & trace_contents))
continue; continue;
CM_ClipBoxToBrush (trace_mins, trace_maxs, trace_start, trace_end, &trace_trace, b); CM_ClipBoxToBrush (M, trace_mins, trace_maxs, trace_start, trace_end, &trace_trace, b);
if (!trace_trace.fraction) if (!trace_trace.fraction)
return; return;
} }
@ -583,7 +583,7 @@ PENTA: Clips to the given brush model
Q3 doesn't have bsp's associated with map models anymore, just a list of brushes Q3 doesn't have bsp's associated with map models anymore, just a list of brushes
================ ================
*/ */
void CM_TraceToBrushModel (int firstbrush, int numbrushes, vec3_t mins, vec3_t maxs, void CM_TraceToBrushModel (model_t *M, int firstbrush, int numbrushes, vec3_t mins, vec3_t maxs,
vec3_t start, vec3_t end, trace_t *trace, int brushmask) vec3_t start, vec3_t end, trace_t *trace, int brushmask)
{ {
int i, brushnum; int i, brushnum;
@ -605,7 +605,7 @@ void CM_TraceToBrushModel (int firstbrush, int numbrushes, vec3_t mins, vec3_t m
if ( !(b->contents & trace_contents)) if ( !(b->contents & trace_contents))
continue; continue;
CM_ClipBoxToBrush (mins, maxs, start, end, trace, b); CM_ClipBoxToBrush (M, mins, maxs, start, end, trace, b);
if (!trace->fraction) if (!trace->fraction)
return; return;
} }
@ -627,7 +627,7 @@ void CM_TraceToBrushModel (int firstbrush, int numbrushes, vec3_t mins, vec3_t m
CM_TestInLeaf CM_TestInLeaf
================ ================
*/ */
void CM_TestInLeaf (int leafnum) void CM_TestInLeaf (model_t *M, int leafnum)
{ {
int k; int k;
int brushnum; int brushnum;
@ -648,7 +648,7 @@ void CM_TestInLeaf (int leafnum)
if ( !(b->contents & trace_contents)) if ( !(b->contents & trace_contents))
continue; continue;
CM_TestBoxInBrush (trace_mins, trace_maxs, trace_start, &trace_trace, b); CM_TestBoxInBrush (M, trace_mins, trace_maxs, trace_start, &trace_trace, b);
if (!trace_trace.fraction) if (!trace_trace.fraction)
return; return;
} }
@ -662,7 +662,7 @@ CM_RecursiveHullCheck
================== ==================
*/ */
void CM_RecursiveHullCheck (int num, float p1f, float p2f, vec3_t p1, vec3_t p2) void CM_RecursiveHullCheck (model_t *M, int num, float p1f, float p2f, vec3_t p1, vec3_t p2)
{ {
mnode_t *node; mnode_t *node;
mplane_t *plane; mplane_t *plane;
@ -680,7 +680,7 @@ void CM_RecursiveHullCheck (int num, float p1f, float p2f, vec3_t p1, vec3_t p2)
// if < 0, we are in a leaf node // if < 0, we are in a leaf node
if (num < 0) if (num < 0)
{ {
CM_TraceToLeaf (-1-num); CM_TraceToLeaf (M, -1-num);
return; return;
} }
@ -711,20 +711,20 @@ void CM_RecursiveHullCheck (int num, float p1f, float p2f, vec3_t p1, vec3_t p2)
#if 0 #if 0
CM_RecursiveHullCheck (node->ichildren[0], p1f, p2f, p1, p2); CM_RecursiveHullCheck (M, node->ichildren[0], p1f, p2f, p1, p2);
CM_RecursiveHullCheck (node->ichildren[1], p1f, p2f, p1, p2); CM_RecursiveHullCheck (M, node->ichildren[1], p1f, p2f, p1, p2);
return; return;
#endif #endif
// see which sides we need to consider // see which sides we need to consider
if (t1 >= offset && t2 >= offset) if (t1 >= offset && t2 >= offset)
{ {
CM_RecursiveHullCheck (node->ichildren[0], p1f, p2f, p1, p2); CM_RecursiveHullCheck (M, node->ichildren[0], p1f, p2f, p1, p2);
return; return;
} }
if (t1 < -offset && t2 < -offset) if (t1 < -offset && t2 < -offset)
{ {
CM_RecursiveHullCheck (node->ichildren[1], p1f, p2f, p1, p2); CM_RecursiveHullCheck (M, node->ichildren[1], p1f, p2f, p1, p2);
return; return;
} }
@ -760,7 +760,7 @@ return;
for (i=0 ; i<3 ; i++) for (i=0 ; i<3 ; i++)
mid[i] = p1[i] + frac*(p2[i] - p1[i]); mid[i] = p1[i] + frac*(p2[i] - p1[i]);
CM_RecursiveHullCheck (node->ichildren[side], p1f, midf, p1, mid); CM_RecursiveHullCheck (M, node->ichildren[side], p1f, midf, p1, mid);
// go past the node // go past the node
@ -773,7 +773,7 @@ return;
for (i=0 ; i<3 ; i++) for (i=0 ; i<3 ; i++)
mid[i] = p1[i] + frac2*(p2[i] - p1[i]); mid[i] = p1[i] + frac2*(p2[i] - p1[i]);
CM_RecursiveHullCheck (node->ichildren[side^1], midf, p2f, mid, p2); CM_RecursiveHullCheck (M, node->ichildren[side^1], midf, p2f, mid, p2);
} }
@ -785,7 +785,7 @@ return;
CM_BoxTrace CM_BoxTrace
================== ==================
*/ */
trace_t CM_BoxTrace (vec3_t start, vec3_t end, trace_t CM_BoxTrace (model_t *M, vec3_t start, vec3_t end,
vec3_t mins, vec3_t maxs, vec3_t mins, vec3_t maxs,
int headnode, int brushmask) int headnode, int brushmask)
{ {
@ -828,10 +828,10 @@ trace_t CM_BoxTrace (vec3_t start, vec3_t end,
c2[i] += 1; c2[i] += 1;
} }
numleafs = CM_BoxLeafnums_headnode (c1, c2, leafs, 1024, headnode, &topnode); numleafs = CM_BoxLeafnums_headnode (M, c1, c2, leafs, 1024, headnode, &topnode);
for (i=0 ; i<numleafs ; i++) for (i=0 ; i<numleafs ; i++)
{ {
CM_TestInLeaf (leafs[i]); CM_TestInLeaf (M, leafs[i]);
if (trace_trace.allsolid) if (trace_trace.allsolid)
break; break;
} }
@ -859,7 +859,7 @@ trace_t CM_BoxTrace (vec3_t start, vec3_t end,
// //
// general sweeping through world // general sweeping through world
// //
CM_RecursiveHullCheck (headnode, 0, 1, start, end); CM_RecursiveHullCheck (M, headnode, 0, 1, start, end);
if (trace_trace.fraction == 1) if (trace_trace.fraction == 1)
{ {
@ -887,7 +887,7 @@ rotating entities
#endif #endif
trace_t CM_TransformedBoxTrace (vec3_t start, vec3_t end, trace_t CM_TransformedBoxTrace (model_t *M, vec3_t start, vec3_t end,
vec3_t mins, vec3_t maxs, vec3_t mins, vec3_t maxs,
int headnode, int brushmask, int headnode, int brushmask,
vec3_t origin, vec3_t angles) vec3_t origin, vec3_t angles)
@ -925,7 +925,7 @@ trace_t CM_TransformedBoxTrace (vec3_t start, vec3_t end,
} }
// sweep the box through the model // sweep the box through the model
trace = CM_BoxTrace (start_l, end_l, mins, maxs, headnode, brushmask); trace = CM_BoxTrace (M, start_l, end_l, mins, maxs, headnode, brushmask);
if (rotated && trace.fraction != 1.0) if (rotated && trace.fraction != 1.0)
{ {
@ -1047,7 +1047,7 @@ FloodAreaConnections
==================== ====================
*/ */
void FloodAreaConnections (void) void FloodAreaConnections (model_t *M)
{ {
int i, j; int i, j;
@ -1060,7 +1060,7 @@ void FloodAreaConnections (void)
} }
} }
void CM_SetAreaPortalState (int area1, int area2, qboolean open) void CM_SetAreaPortalState (model_t *M, int area1, int area2, qboolean open)
{ {
if (area1 > M->numareas || area2 > M->numareas) { if (area1 > M->numareas || area2 > M->numareas) {
Con_Printf ("CM_SetAreaPortalState: area > M->numareas\n"); Con_Printf ("CM_SetAreaPortalState: area > M->numareas\n");
@ -1085,7 +1085,7 @@ void CM_SetAreaPortalState (int area1, int area2, qboolean open)
} }
} }
qboolean CM_AreasConnected (int area1, int area2) qboolean CM_AreasConnected (model_t *M, int area1, int area2)
{ {
int i; int i;
/* /*
@ -1120,7 +1120,7 @@ that area in the same flood as the area parameter
This is used by the client refreshes to cull visibility This is used by the client refreshes to cull visibility
================= =================
*/ */
int CM_WriteAreaBits (byte *buffer, int area) int CM_WriteAreaBits (model_t *M, byte *buffer, int area)
{ {
int i; int i;
int bytes; int bytes;
@ -1138,7 +1138,7 @@ int CM_WriteAreaBits (byte *buffer, int area)
for (i=1 ; i<M->numareas ; i++) for (i=1 ; i<M->numareas ; i++)
{ {
if (!area || CM_AreasConnected ( i, area ) || i == area) if (!area || CM_AreasConnected (M, i, area ) || i == area)
buffer[i>>3] |= 1<<(i&7); buffer[i>>3] |= 1<<(i&7);
} }
} }
@ -1153,13 +1153,13 @@ int CM_WriteAreaBits (byte *buffer, int area)
CM_MergeAreaBits CM_MergeAreaBits
================= =================
*/ */
void CM_MergeAreaBits (byte *buffer, int area) void CM_MergeAreaBits (model_t *M, byte *buffer, int area)
{ {
int i; int i;
for (i=1 ; i<M->numareas ; i++) for (i=1 ; i<M->numareas ; i++)
{ {
if ( CM_AreasConnected ( i, area ) || i == area) if ( CM_AreasConnected (M, i, area ) || i == area)
buffer[i>>3] |= 1<<(i&7); buffer[i>>3] |= 1<<(i&7);
} }
} }
@ -1171,7 +1171,7 @@ CM_WritePortalState
Writes the portal state to a savegame file Writes the portal state to a savegame file
=================== ===================
*/ */
void CM_WritePortalState (FILE *f) void CM_WritePortalState (model_t *M, FILE *f)
{ {
} }
@ -1183,7 +1183,7 @@ Reads the portal state from a savegame file
and recalculates the area connections and recalculates the area connections
=================== ===================
*/ */
void CM_ReadPortalState (FILE *f) void CM_ReadPortalState (model_t *M, FILE *f)
{ {
} }

10
world.c
View file

@ -253,7 +253,7 @@ SV_ClearWorld
void SV_ClearWorld (void) void SV_ClearWorld (void)
{ {
SV_InitBoxHull (); SV_InitBoxHull ();
CM_InitBoxHull (); CM_InitBoxHull (sv.worldmodel);
memset (sv_areanodes, 0, sizeof(sv_areanodes)); memset (sv_areanodes, 0, sizeof(sv_areanodes));
sv_numareanodes = 0; sv_numareanodes = 0;
@ -562,7 +562,7 @@ int SV_PointContents (vec3_t p)
int cont; int cont;
//cont = SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p); //cont = SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p);
cont = CM_PointContents(p,0); cont = CM_PointContents(sv.worldmodel, p,0);
if (cont <= CONTENTS_CURRENT_0 && cont >= CONTENTS_CURRENT_DOWN) if (cont <= CONTENTS_CURRENT_0 && cont >= CONTENTS_CURRENT_DOWN)
cont = CONTENTS_WATER; cont = CONTENTS_WATER;
return cont; return cont;
@ -591,7 +591,7 @@ int SV_SimplePointContents (int c)
int SV_TruePointContents (vec3_t p) int SV_TruePointContents (vec3_t p)
{ {
// return SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p); // return SV_HullPointContents (&sv.worldmodel->hulls[0], 0, p);
return CM_PointContents(p,0); return CM_PointContents(sv.worldmodel, p,0);
} }
//=========================================================================== //===========================================================================
@ -845,7 +845,7 @@ trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t max
// trace a line through the apropriate brushes // trace a line through the apropriate brushes
//SV_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace); //SV_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace);
CM_TraceToBrushModel (firstbrush, numbrushes, mins, maxs, start_l, end_l, &trace, CONTENTS_SOLID); CM_TraceToBrushModel (sv.worldmodel, firstbrush, numbrushes, mins, maxs, start_l, end_l, &trace, CONTENTS_SOLID);
// rotate endpos back to world frame of reference // rotate endpos back to world frame of reference
if (rotated && trace.fraction != 1.0) if (rotated && trace.fraction != 1.0)
@ -1013,7 +1013,7 @@ trace_t SV_Move (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, e
// clip to world // clip to world
//clip.trace = SV_ClipMoveToEntity ( sv.edicts, start, mins, maxs, end ); //clip.trace = SV_ClipMoveToEntity ( sv.edicts, start, mins, maxs, end );
clip.trace = CM_BoxTrace (start, end, mins, maxs, 0, CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP); clip.trace = CM_BoxTrace (sv.worldmodel, start, end, mins, maxs, 0, CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP);
clip.trace.ent = &sv.edicts[0]; //world clip.trace.ent = &sv.edicts[0]; //world
if (clip.trace.fraction == 0) if (clip.trace.fraction == 0)