#include "quakedef.h"
#include "clvm_cmds.h"
#include "cl_collision.h"
+#include "com_list.h"
/*
*/
+#ifdef USEODE
static void World_Physics_Init(void);
+#endif
void World_Init(void)
{
Collision_Init();
+#ifdef USEODE
World_Physics_Init();
+#endif
}
+#ifdef USEODE
static void World_Physics_Shutdown(void);
+#endif
void World_Shutdown(void)
{
+#ifdef USEODE
World_Physics_Shutdown();
+#endif
}
+#ifdef USEODE
static void World_Physics_Start(world_t *world);
+#endif
void World_Start(world_t *world)
{
+#ifdef USEODE
World_Physics_Start(world);
+#endif
}
+#ifdef USEODE
static void World_Physics_End(world_t *world);
+#endif
void World_End(world_t *world)
{
+#ifdef USEODE
World_Physics_End(world);
+#endif
}
//============================================================================
// unlink all entities one by one
grid = &world->areagrid_outside;
while (grid->list.next != &grid->list)
- World_UnlinkEdict(PRVM_EDICT_NUM(List_Container(*grid->list.next, link_t, list)->entitynumber));
+ World_UnlinkEdict(PRVM_EDICT_NUM(List_Entry(grid->list.next, link_t, list)->entitynumber));
for (i = 0, grid = world->areagrid;i < AREA_GRIDNODES;i++, grid++)
while (grid->list.next != &grid->list)
- World_UnlinkEdict(PRVM_EDICT_NUM(List_Container(*grid->list.next, link_t, list)->entitynumber));
+ World_UnlinkEdict(PRVM_EDICT_NUM(List_Entry(grid->list.next, link_t, list)->entitynumber));
}
/*
{
prvm_prog_t *prog = world->prog;
int numlist;
- llist_t *pos;
link_t *grid;
link_t *l;
prvm_edict_t *ent;
if (world->areagrid_outside.list.next)
{
grid = &world->areagrid_outside;
- List_ForEach(pos, &grid->list)
+ List_For_Each_Entry(l, &grid->list, link_t, list)
{
- l = List_Container(*pos, link_t, list);
ent = PRVM_EDICT_NUM(l->entitynumber);
if (ent->priv.server->areagridmarknumber != world->areagrid_marknumber)
{
ent->priv.server->areagridmarknumber = world->areagrid_marknumber;
- if (!ent->priv.server->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
+ if (!ent->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
{
if (numlist < maxlist)
list[numlist] = ent;
{
if (grid->list.next)
{
- List_ForEach(pos, &grid->list)
+ List_For_Each_Entry(l, &grid->list, link_t, list)
{
- l = List_Container(*pos, link_t, list);
ent = PRVM_EDICT_NUM(l->entitynumber);
if (ent->priv.server->areagridmarknumber != world->areagrid_marknumber)
{
ent->priv.server->areagridmarknumber = world->areagrid_marknumber;
- if (!ent->priv.server->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
+ if (!ent->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
{
if (numlist < maxlist)
list[numlist] = ent;
return;
// don't add free entities
- if (ent->priv.server->free)
+ if (ent->free)
return;
VectorCopy(mins, ent->priv.server->areamins);
//============================================================================
#ifdef USEODE
-cvar_t physics_ode_quadtree_depth = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_quadtree_depth","5", "desired subdivision level of quadtree culling space"};
-cvar_t physics_ode_allowconvex = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_allowconvex", "0", "allow usage of Convex Hull primitive type on trimeshes that have custom 'collisionconvex' mesh. If disabled, trimesh primitive type are used."};
-cvar_t physics_ode_contactsurfacelayer = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_contactsurfacelayer","1", "allows objects to overlap this many units to reduce jitter"};
-cvar_t physics_ode_worldstep_iterations = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_worldstep_iterations", "20", "parameter to dWorldQuickStep"};
-cvar_t physics_ode_contact_mu = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_contact_mu", "1", "contact solver mu parameter - friction pyramid approximation 1 (see ODE User Guide)"};
-cvar_t physics_ode_contact_erp = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_contact_erp", "0.96", "contact solver erp parameter - Error Restitution Percent (see ODE User Guide)"};
-cvar_t physics_ode_contact_cfm = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_contact_cfm", "0", "contact solver cfm parameter - Constraint Force Mixing (see ODE User Guide)"};
-cvar_t physics_ode_contact_maxpoints = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_contact_maxpoints", "16", "maximal number of contact points between 2 objects, higher = stable (and slower), can be up to 32"};
-cvar_t physics_ode_world_erp = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_erp", "-1", "world solver erp parameter - Error Restitution Percent (see ODE User Guide); use defaults when set to -1"};
-cvar_t physics_ode_world_cfm = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_cfm", "-1", "world solver cfm parameter - Constraint Force Mixing (see ODE User Guide); not touched when -1"};
-cvar_t physics_ode_world_damping = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_damping", "1", "enabled damping scale (see ODE User Guide), this scales all damping values, be aware that behavior depends of step type"};
-cvar_t physics_ode_world_damping_linear = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_damping_linear", "0.01", "world linear damping scale (see ODE User Guide); use defaults when set to -1"};
-cvar_t physics_ode_world_damping_linear_threshold = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_damping_linear_threshold", "0.1", "world linear damping threshold (see ODE User Guide); use defaults when set to -1"};
-cvar_t physics_ode_world_damping_angular = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_damping_angular", "0.05", "world angular damping scale (see ODE User Guide); use defaults when set to -1"};
-cvar_t physics_ode_world_damping_angular_threshold = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_damping_angular_threshold", "0.1", "world angular damping threshold (see ODE User Guide); use defaults when set to -1"};
-cvar_t physics_ode_world_gravitymod = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_world_gravitymod", "1", "multiplies gravity got from sv_gravity, this may be needed to tweak if strong damping is used"};
-cvar_t physics_ode_iterationsperframe = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_iterationsperframe", "1", "divisor for time step, runs multiple physics steps per frame"};
-cvar_t physics_ode_constantstep = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_constantstep", "0", "use constant step instead of variable step which tends to increase stability, if set to 1 uses sys_ticrate, instead uses it's own value"};
-cvar_t physics_ode_autodisable = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable", "1", "automatic disabling of objects which dont move for long period of time, makes object stacking a lot faster"};
-cvar_t physics_ode_autodisable_steps = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable_steps", "10", "how many steps object should be dormant to be autodisabled"};
-cvar_t physics_ode_autodisable_time = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable_time", "0", "how many seconds object should be dormant to be autodisabled"};
-cvar_t physics_ode_autodisable_threshold_linear = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable_threshold_linear", "0.6", "body will be disabled if it's linear move below this value"};
-cvar_t physics_ode_autodisable_threshold_angular = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable_threshold_angular", "6", "body will be disabled if it's angular move below this value"};
-cvar_t physics_ode_autodisable_threshold_samples = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_autodisable_threshold_samples", "5", "average threshold with this number of samples"};
-cvar_t physics_ode_movelimit = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_movelimit", "0.5", "clamp velocity if a single move would exceed this percentage of object thickness, to prevent flying through walls, be aware that behavior depends of step type"};
-cvar_t physics_ode_spinlimit = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_spinlimit", "10000", "reset spin velocity if it gets too large"};
-cvar_t physics_ode_trick_fixnan = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_trick_fixnan", "1", "engine trick that checks and fixes NaN velocity/origin/angles on objects, a value of 2 makes console prints on each fix"};
-cvar_t physics_ode_printstats = {CVAR_CLIENT | CVAR_SERVER, "physics_ode_printstats", "0", "print ODE stats each frame"};
-
-cvar_t physics_ode = {CVAR_CLIENT | CVAR_SERVER, "physics_ode", "0", "run ODE physics (VERY experimental and potentially buggy)"};
+cvar_t physics_ode_quadtree_depth = {CF_CLIENT | CF_SERVER, "physics_ode_quadtree_depth","5", "desired subdivision level of quadtree culling space"};
+cvar_t physics_ode_allowconvex = {CF_CLIENT | CF_SERVER, "physics_ode_allowconvex", "0", "allow usage of Convex Hull primitive type on trimeshes that have custom 'collisionconvex' mesh. If disabled, trimesh primitive type are used."};
+cvar_t physics_ode_contactsurfacelayer = {CF_CLIENT | CF_SERVER, "physics_ode_contactsurfacelayer","1", "allows objects to overlap this many units to reduce jitter"};
+cvar_t physics_ode_worldstep_iterations = {CF_CLIENT | CF_SERVER, "physics_ode_worldstep_iterations", "20", "parameter to dWorldQuickStep"};
+cvar_t physics_ode_contact_mu = {CF_CLIENT | CF_SERVER, "physics_ode_contact_mu", "1", "contact solver mu parameter - friction pyramid approximation 1 (see ODE User Guide)"};
+cvar_t physics_ode_contact_erp = {CF_CLIENT | CF_SERVER, "physics_ode_contact_erp", "0.96", "contact solver erp parameter - Error Restitution Percent (see ODE User Guide)"};
+cvar_t physics_ode_contact_cfm = {CF_CLIENT | CF_SERVER, "physics_ode_contact_cfm", "0", "contact solver cfm parameter - Constraint Force Mixing (see ODE User Guide)"};
+cvar_t physics_ode_contact_maxpoints = {CF_CLIENT | CF_SERVER, "physics_ode_contact_maxpoints", "16", "maximal number of contact points between 2 objects, higher = stable (and slower), can be up to 32"};
+cvar_t physics_ode_world_erp = {CF_CLIENT | CF_SERVER, "physics_ode_world_erp", "-1", "world solver erp parameter - Error Restitution Percent (see ODE User Guide); use defaults when set to -1"};
+cvar_t physics_ode_world_cfm = {CF_CLIENT | CF_SERVER, "physics_ode_world_cfm", "-1", "world solver cfm parameter - Constraint Force Mixing (see ODE User Guide); not touched when -1"};
+cvar_t physics_ode_world_damping = {CF_CLIENT | CF_SERVER, "physics_ode_world_damping", "1", "enabled damping scale (see ODE User Guide), this scales all damping values, be aware that behavior depends of step type"};
+cvar_t physics_ode_world_damping_linear = {CF_CLIENT | CF_SERVER, "physics_ode_world_damping_linear", "0.01", "world linear damping scale (see ODE User Guide); use defaults when set to -1"};
+cvar_t physics_ode_world_damping_linear_threshold = {CF_CLIENT | CF_SERVER, "physics_ode_world_damping_linear_threshold", "0.1", "world linear damping threshold (see ODE User Guide); use defaults when set to -1"};
+cvar_t physics_ode_world_damping_angular = {CF_CLIENT | CF_SERVER, "physics_ode_world_damping_angular", "0.05", "world angular damping scale (see ODE User Guide); use defaults when set to -1"};
+cvar_t physics_ode_world_damping_angular_threshold = {CF_CLIENT | CF_SERVER, "physics_ode_world_damping_angular_threshold", "0.1", "world angular damping threshold (see ODE User Guide); use defaults when set to -1"};
+cvar_t physics_ode_world_gravitymod = {CF_CLIENT | CF_SERVER, "physics_ode_world_gravitymod", "1", "multiplies gravity got from sv_gravity, this may be needed to tweak if strong damping is used"};
+cvar_t physics_ode_iterationsperframe = {CF_CLIENT | CF_SERVER, "physics_ode_iterationsperframe", "1", "divisor for time step, runs multiple physics steps per frame"};
+cvar_t physics_ode_constantstep = {CF_CLIENT | CF_SERVER, "physics_ode_constantstep", "0", "use constant step instead of variable step which tends to increase stability, if set to 1 uses sys_ticrate, instead uses it's own value"};
+cvar_t physics_ode_autodisable = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable", "1", "automatic disabling of objects which dont move for long period of time, makes object stacking a lot faster"};
+cvar_t physics_ode_autodisable_steps = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable_steps", "10", "how many steps object should be dormant to be autodisabled"};
+cvar_t physics_ode_autodisable_time = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable_time", "0", "how many seconds object should be dormant to be autodisabled"};
+cvar_t physics_ode_autodisable_threshold_linear = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable_threshold_linear", "0.6", "body will be disabled if it's linear move below this value"};
+cvar_t physics_ode_autodisable_threshold_angular = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable_threshold_angular", "6", "body will be disabled if it's angular move below this value"};
+cvar_t physics_ode_autodisable_threshold_samples = {CF_CLIENT | CF_SERVER, "physics_ode_autodisable_threshold_samples", "5", "average threshold with this number of samples"};
+cvar_t physics_ode_movelimit = {CF_CLIENT | CF_SERVER, "physics_ode_movelimit", "0.5", "clamp velocity if a single move would exceed this percentage of object thickness, to prevent flying through walls, be aware that behavior depends of step type"};
+cvar_t physics_ode_spinlimit = {CF_CLIENT | CF_SERVER, "physics_ode_spinlimit", "10000", "reset spin velocity if it gets too large"};
+cvar_t physics_ode_trick_fixnan = {CF_CLIENT | CF_SERVER, "physics_ode_trick_fixnan", "1", "engine trick that checks and fixes NaN velocity/origin/angles on objects, a value of 2 makes console prints on each fix"};
+cvar_t physics_ode_printstats = {CF_CLIENT | CF_SERVER, "physics_ode_printstats", "0", "print ODE stats each frame"};
+
+cvar_t physics_ode = {CF_CLIENT | CF_SERVER, "physics_ode", "0", "run ODE physics (VERY experimental and potentially buggy)"};
// LadyHavoc: this large chunk of definitions comes from the ODE library
// include files.
// {"dGeomTriMeshDataUpdate", (void **) &dGeomTriMeshDataUpdate},
{NULL, NULL}
};
-
// Handle for ODE DLL
dllhandle_t ode_dll = NULL;
#endif
-#endif
static void World_Physics_Init(void)
{
-#ifdef USEODE
#ifndef LINK_TO_LIBODE
const char* dllnames [] =
{
#ifndef LINK_TO_LIBODE
// Load the DLL
- if (Sys_LoadLibrary (dllnames, &ode_dll, odefuncs))
+ if (Sys_LoadDependency (dllnames, &ode_dll, odefuncs))
#endif
{
dInitODE();
# else
Con_Printf("ODE library not compiled for double precision - incompatible! Not using ODE physics.\n");
# endif
- Sys_UnloadLibrary(&ode_dll);
+ Sys_FreeLibrary(&ode_dll);
ode_dll = NULL;
}
else
}
#endif
}
-#endif
}
-
static void World_Physics_Shutdown(void)
{
-#ifdef USEODE
#ifndef LINK_TO_LIBODE
if (ode_dll)
#endif
{
dCloseODE();
#ifndef LINK_TO_LIBODE
- Sys_UnloadLibrary(&ode_dll);
+ Sys_FreeLibrary(&ode_dll);
ode_dll = NULL;
#endif
}
-#endif
}
-#ifdef USEODE
static void World_Physics_UpdateODE(world_t *world)
{
dWorldID odeworld;
World_Physics_UpdateODE(world);
}
-#endif
static void World_Physics_Start(world_t *world)
{
-#ifdef USEODE
if (world->physics.ode)
return;
World_Physics_EnableODE(world);
-#endif
}
static void World_Physics_End(world_t *world)
{
-#ifdef USEODE
if (world->physics.ode)
{
dWorldDestroy((dWorldID)world->physics.ode_world);
dJointGroupDestroy((dJointGroupID)world->physics.ode_contactgroup);
world->physics.ode = false;
}
-#endif
}
void World_Physics_RemoveJointFromEntity(world_t *world, prvm_edict_t *ed)
{
ed->priv.server->ode_joint_type = 0;
-#ifdef USEODE
if(ed->priv.server->ode_joint)
dJointDestroy((dJointID)ed->priv.server->ode_joint);
ed->priv.server->ode_joint = NULL;
-#endif
}
void World_Physics_RemoveFromEntity(world_t *world, prvm_edict_t *ed)
// entity is not physics controlled, free any physics data
ed->priv.server->ode_physics = false;
-#ifdef USEODE
if (ed->priv.server->ode_geom)
dGeomDestroy((dGeomID)ed->priv.server->ode_geom);
ed->priv.server->ode_geom = NULL;
dBodyDestroy((dBodyID)ed->priv.server->ode_body);
}
ed->priv.server->ode_body = NULL;
-#endif
if (ed->priv.server->ode_vertex3f)
Mem_Free(ed->priv.server->ode_vertex3f);
ed->priv.server->ode_vertex3f = NULL;
void World_Physics_ApplyCmd(prvm_edict_t *ed, edict_odefunc_t *f)
{
-#ifdef USEODE
dBodyID body = (dBodyID)ed->priv.server->ode_body;
switch(f->type)
default:
break;
}
-#endif
}
-#ifdef USEODE
static void World_Physics_Frame_BodyToEntity(world_t *world, prvm_edict_t *ed)
{
prvm_prog_t *prog = world->prog;
if (!forcetype)
return;
enemy = PRVM_gameedictedict(ed, enemy);
- if (enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].priv.required->free || prog->edicts[enemy].priv.server->ode_body == 0)
+ if (enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].free || prog->edicts[enemy].priv.server->ode_body == 0)
return;
VectorCopy(PRVM_gameedictvector(ed, movedir), movedir);
VectorCopy(PRVM_gameedictvector(ed, origin), origin);
VectorCopy(PRVM_gameedictvector(ed, movedir), movedir);
if(movetype == MOVETYPE_PHYSICS)
jointtype = JOINTTYPE_NONE; // can't have both
- if(enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].priv.required->free || prog->edicts[enemy].priv.server->ode_body == 0)
+ if(enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].free || prog->edicts[enemy].priv.server->ode_body == 0)
enemy = 0;
- if(aiment <= 0 || aiment >= prog->num_edicts || prog->edicts[aiment].priv.required->free || prog->edicts[aiment].priv.server->ode_body == 0)
+ if(aiment <= 0 || aiment >= prog->num_edicts || prog->edicts[aiment].free || prog->edicts[aiment].priv.server->ode_body == 0)
aiment = 0;
// see http://www.ode.org/old_list_archives/2006-January/017614.html
// we want to set ERP? make it fps independent and work like a spring constant
dMass mass;
const dReal *ovelocity, *ospinvelocity;
void *dataID;
- dp_model_t *model;
+ model_t *model;
float *ov;
int *oe;
int axisindex;
int triangleindex;
int vertexindex;
mempool_t *mempool;
- qboolean modified = false;
+ qbool modified = false;
vec3_t angles;
vec3_t avelocity;
vec3_t entmaxs;
vec3_t scale;
vec_t spinlimit;
vec_t test;
- qboolean gravity;
- qboolean geom_modified = false;
+ qbool gravity;
+ qbool geom_modified = false;
edict_odefunc_t *func, *nextf;
dReal *planes, *planesData, *pointsData;
unsigned int *polygons, *polygonsData, polyvert;
- qboolean *mapped, *used, convex_compatible;
+ qbool *mapped, *used, convex_compatible;
int numplanes = 0, numpoints = 0, i;
#ifndef LINK_TO_LIBODE
// check if trimesh can be defined with convex
convex_compatible = false;
- for (i = 0;i < model->nummodelsurfaces;i++)
+ for (i = model->submodelsurfaces_start;i < model->submodelsurfaces_end;i++)
{
- if (!strcmp(((msurface_t *)(model->data_surfaces + model->firstmodelsurface + i))->texture->name, "collisionconvex"))
+ if (!strcmp(model->data_surfaces[i].texture->name, "collisionconvex"))
{
convex_compatible = true;
break;
// followed by that amount of indices to "points" in counter clockwise order
polygonsData = polygons = (unsigned int *)Mem_Alloc(mempool, numtriangles*sizeof(int)*4);
planesData = planes = (dReal *)Mem_Alloc(mempool, numtriangles*sizeof(dReal)*4);
- mapped = (qboolean *)Mem_Alloc(mempool, numvertices*sizeof(qboolean));
- used = (qboolean *)Mem_Alloc(mempool, numtriangles*sizeof(qboolean));
- memset(mapped, 0, numvertices*sizeof(qboolean));
- memset(used, 0, numtriangles*sizeof(qboolean));
+ mapped = (qbool *)Mem_Alloc(mempool, numvertices*sizeof(qbool));
+ used = (qbool *)Mem_Alloc(mempool, numtriangles*sizeof(qbool));
+ memset(mapped, 0, numvertices*sizeof(qbool));
+ memset(used, 0, numtriangles*sizeof(qbool));
numplanes = numpoints = polyvert = 0;
// build convex hull
// todo: merge duplicated verts here
return;
ed1 = (prvm_edict_t *) dGeomGetData(o1);
- if(ed1 && ed1->priv.server->free)
+ if(ed1 && ed1->free)
ed1 = NULL;
if(ed1)
{
}
ed2 = (prvm_edict_t *) dGeomGetData(o2);
- if(ed2 && ed2->priv.server->free)
+ if(ed2 && ed2->free)
ed2 = NULL;
if(ed2)
{
dJointAttach(c, b1, b2);
}
}
-#endif
void World_Physics_Frame(world_t *world, double frametime, double gravity)
{
-#ifdef USEODE
prvm_prog_t *prog = world->prog;
double tdelta, tdelta2, tdelta3, simulationtime, collisiontime;
if (prog)
{
for (i = 0, ed = prog->edicts + i;i < prog->num_edicts;i++, ed++)
- if (!prog->edicts[i].priv.required->free)
+ if (!prog->edicts[i].free)
World_Physics_Frame_BodyFromEntity(world, ed);
// oh, and it must be called after all bodies were created
for (i = 0, ed = prog->edicts + i;i < prog->num_edicts;i++, ed++)
- if (!prog->edicts[i].priv.required->free)
+ if (!prog->edicts[i].free)
World_Physics_Frame_JointFromEntity(world, ed);
}
{
int j;
for (j = 0, ed = prog->edicts + j;j < prog->num_edicts;j++, ed++)
- if (!prog->edicts[j].priv.required->free)
+ if (!prog->edicts[j].free)
World_Physics_Frame_ForceFromEntity(world, ed);
}
// run physics (move objects, calculate new velocities)
if (prog)
{
for (i = 1, ed = prog->edicts + i;i < prog->num_edicts;i++, ed++)
- if (!prog->edicts[i].priv.required->free)
+ if (!prog->edicts[i].free)
World_Physics_Frame_BodyToEntity(world, ed);
// print stats
world->physics.ode_activeovjects = 0;
for (i = 1, ed = prog->edicts + i;i < prog->num_edicts;i++, ed++)
{
- if (prog->edicts[i].priv.required->free)
+ if (prog->edicts[i].free)
continue;
body = (dBodyID)prog->edicts[i].priv.server->ode_body;
if (!body)
}
}
}
-#endif
}
+#endif
projects / xonotic / darkplaces.git / blobdiff