===============
*/
-void World_SetSize(world_t *world, const char *filename, const vec3_t mins, const vec3_t maxs)
+void World_SetSize(world_t *world, const char *filename, const vec3_t mins, const vec3_t maxs, prvm_prog_t *prog)
{
int i;
strlcpy(world->filename, filename, sizeof(world->filename));
VectorCopy(mins, world->mins);
VectorCopy(maxs, world->maxs);
+ world->prog = prog;
// the areagrid_marknumber is not allowed to be 0
if (world->areagrid_marknumber < 1)
*/
void World_UnlinkAll(world_t *world)
{
+ prvm_prog_t *prog = world->prog;
int i;
link_t *grid;
// unlink all entities one by one
}
}
-int World_EntitiesInBox(world_t *world, const vec3_t mins, const vec3_t maxs, int maxlist, prvm_edict_t **list)
+int World_EntitiesInBox(world_t *world, const vec3_t requestmins, const vec3_t requestmaxs, int maxlist, prvm_edict_t **list)
{
+ prvm_prog_t *prog = world->prog;
int numlist;
link_t *grid;
link_t *l;
prvm_edict_t *ent;
+ vec3_t paddedmins, paddedmaxs;
int igrid[3], igridmins[3], igridmaxs[3];
+ VectorSet(paddedmins, requestmins[0] - 1.0f, requestmins[1] - 1.0f, requestmins[2] - 1.0f);
+ VectorSet(paddedmaxs, requestmaxs[0] + 1.0f, requestmaxs[1] + 1.0f, requestmaxs[2] + 1.0f);
+
// FIXME: if areagrid_marknumber wraps, all entities need their
// ent->priv.server->areagridmarknumber reset
world->areagrid_stats_calls++;
world->areagrid_marknumber++;
- igridmins[0] = (int) floor((mins[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]);
- igridmins[1] = (int) floor((mins[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]);
- //igridmins[2] = (int) ((mins[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]);
- igridmaxs[0] = (int) floor((maxs[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]) + 1;
- igridmaxs[1] = (int) floor((maxs[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]) + 1;
- //igridmaxs[2] = (int) ((maxs[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]) + 1;
+ igridmins[0] = (int) floor((paddedmins[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]);
+ igridmins[1] = (int) floor((paddedmins[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]);
+ //igridmins[2] = (int) ((paddedmins[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]);
+ igridmaxs[0] = (int) floor((paddedmaxs[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]) + 1;
+ igridmaxs[1] = (int) floor((paddedmaxs[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]) + 1;
+ //igridmaxs[2] = (int) ((paddedmaxs[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]) + 1;
igridmins[0] = max(0, igridmins[0]);
igridmins[1] = max(0, igridmins[1]);
//igridmins[2] = max(0, igridmins[2]);
igridmaxs[1] = min(AREA_GRID, igridmaxs[1]);
//igridmaxs[2] = min(AREA_GRID, igridmaxs[2]);
+ // paranoid debugging
+ //VectorSet(igridmins, 0, 0, 0);VectorSet(igridmaxs, AREA_GRID, AREA_GRID, AREA_GRID);
+
numlist = 0;
// add entities not linked into areagrid because they are too big or
// outside the grid bounds
- if (world->areagrid_outside.next != &world->areagrid_outside)
+ if (world->areagrid_outside.next)
{
grid = &world->areagrid_outside;
for (l = grid->next;l != grid;l = l->next)
if (ent->priv.server->areagridmarknumber != world->areagrid_marknumber)
{
ent->priv.server->areagridmarknumber = world->areagrid_marknumber;
- if (!ent->priv.server->free && BoxesOverlap(mins, maxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
+ if (!ent->priv.server->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
{
if (numlist < maxlist)
list[numlist] = ent;
grid = world->areagrid + igrid[1] * AREA_GRID + igridmins[0];
for (igrid[0] = igridmins[0];igrid[0] < igridmaxs[0];igrid[0]++, grid++)
{
- if (grid->next != grid)
+ if (grid->next)
{
for (l = grid->next;l != grid;l = l->next)
{
if (ent->priv.server->areagridmarknumber != world->areagrid_marknumber)
{
ent->priv.server->areagridmarknumber = world->areagrid_marknumber;
- if (!ent->priv.server->free && BoxesOverlap(mins, maxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
+ if (!ent->priv.server->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
{
if (numlist < maxlist)
list[numlist] = ent;
return numlist;
}
-void World_LinkEdict_AreaGrid(world_t *world, prvm_edict_t *ent)
+static void World_LinkEdict_AreaGrid(world_t *world, prvm_edict_t *ent)
{
+ prvm_prog_t *prog = world->prog;
link_t *grid;
int igrid[3], igridmins[3], igridmaxs[3], gridnum, entitynumber = PRVM_NUM_FOR_EDICT(ent);
*/
void World_LinkEdict(world_t *world, prvm_edict_t *ent, const vec3_t mins, const vec3_t maxs)
{
+ prvm_prog_t *prog = world->prog;
// unlink from old position first
if (ent->priv.server->areagrid[0].prev)
World_UnlinkEdict(ent);
#define USEODE 1
#endif
-// recent ODE trunk has dWorldStepFast1 removed
-//#define ODE_USE_STEPFAST
-
#ifdef USEODE
cvar_t physics_ode_quadtree_depth = {0, "physics_ode_quadtree_depth","5", "desired subdivision level of quadtree culling space"};
cvar_t physics_ode_contactsurfacelayer = {0, "physics_ode_contactsurfacelayer","1", "allows objects to overlap this many units to reduce jitter"};
-cvar_t physics_ode_worldstep = {0, "physics_ode_worldstep","2", "step function to use, 0 - dWorldStep, 1 - dWorldStepFast1, 2 - dWorldQuickStep"};
-cvar_t physics_ode_worldstep_iterations = {0, "physics_ode_worldstep_iterations", "20", "parameter to dWorldQuickStep and dWorldStepFast1"};
+cvar_t physics_ode_worldstep_iterations = {0, "physics_ode_worldstep_iterations", "20", "parameter to dWorldQuickStep"};
cvar_t physics_ode_contact_mu = {0, "physics_ode_contact_mu", "1", "contact solver mu parameter - friction pyramid approximation 1 (see ODE User Guide)"};
cvar_t physics_ode_contact_erp = {0, "physics_ode_contact_erp", "0.96", "contact solver erp parameter - Error Restitution Percent (see ODE User Guide)"};
cvar_t physics_ode_contact_cfm = {0, "physics_ode_contact_cfm", "0", "contact solver cfm parameter - Constraint Force Mixing (see ODE User Guide)"};
cvar_t physics_ode_world_damping_angular_threshold = {0, "physics_ode_world_damping_angular_threshold", "0.01", "world angular damping threshold (see ODE User Guide); use defaults when set to -1"};
cvar_t physics_ode_world_gravitymod = {0, "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 = {0, "physics_ode_iterationsperframe", "1", "divisor for time step, runs multiple physics steps per frame"};
-cvar_t physics_ode_constantstep = {0, "physics_ode_constantstep", "1", "use constant step (sys_ticrate value) instead of variable step which tends to increase stability"};
+cvar_t physics_ode_constantstep = {0, "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 = {0, "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 = {0, "physics_ode_autodisable_steps", "10", "how many steps object should be dormant to be autodisabled"};
cvar_t physics_ode_autodisable_time = {0, "physics_ode_autodisable_time", "0", "how many seconds object should be dormant to be autodisabled"};
//dReal (ODE_API *dWorldGetERP)(dWorldID);
void (ODE_API *dWorldSetCFM)(dWorldID, dReal cfm);
//dReal (ODE_API *dWorldGetCFM)(dWorldID);
-void (ODE_API *dWorldStep)(dWorldID, dReal stepsize);
+//void (ODE_API *dWorldStep)(dWorldID, dReal stepsize);
//void (ODE_API *dWorldImpulseToForce)(dWorldID, dReal stepsize, dReal ix, dReal iy, dReal iz, dVector3 force);
void (ODE_API *dWorldQuickStep)(dWorldID w, dReal stepsize);
void (ODE_API *dWorldSetQuickStepNumIterations)(dWorldID, int num);
//dReal (ODE_API *dWorldGetContactMaxCorrectingVel)(dWorldID);
void (ODE_API *dWorldSetContactSurfaceLayer)(dWorldID, dReal depth);
//dReal (ODE_API *dWorldGetContactSurfaceLayer)(dWorldID);
-#ifdef ODE_USE_STEPFAST
-void (ODE_API *dWorldStepFast1)(dWorldID, dReal stepsize, int maxiterations);
-#endif
+//void (ODE_API *dWorldStepFast1)(dWorldID, dReal stepsize, int maxiterations);
//void (ODE_API *dWorldSetAutoEnableDepthSF1)(dWorldID, int autoEnableDepth);
//int (ODE_API *dWorldGetAutoEnableDepthSF1)(dWorldID);
//dReal (ODE_API *dWorldGetAutoDisableLinearThreshold)(dWorldID);
// {"dWorldGetERP", (void **) &dWorldGetERP},
{"dWorldSetCFM", (void **) &dWorldSetCFM},
// {"dWorldGetCFM", (void **) &dWorldGetCFM},
- {"dWorldStep", (void **) &dWorldStep},
+// {"dWorldStep", (void **) &dWorldStep},
// {"dWorldImpulseToForce", (void **) &dWorldImpulseToForce},
{"dWorldQuickStep", (void **) &dWorldQuickStep},
{"dWorldSetQuickStepNumIterations", (void **) &dWorldSetQuickStepNumIterations},
// {"dWorldGetContactMaxCorrectingVel", (void **) &dWorldGetContactMaxCorrectingVel},
{"dWorldSetContactSurfaceLayer", (void **) &dWorldSetContactSurfaceLayer},
// {"dWorldGetContactSurfaceLayer", (void **) &dWorldGetContactSurfaceLayer},
-#ifdef ODE_USE_STEPFAST
- {"dWorldStepFast1", (void **) &dWorldStepFast1},
-#endif
+// {"dWorldStepFast1", (void **) &dWorldStepFast1},
// {"dWorldSetAutoEnableDepthSF1", (void **) &dWorldSetAutoEnableDepthSF1},
// {"dWorldGetAutoEnableDepthSF1", (void **) &dWorldGetAutoEnableDepthSF1},
// {"dWorldGetAutoDisableLinearThreshold", (void **) &dWorldGetAutoDisableLinearThreshold},
Cvar_RegisterVariable(&physics_ode_quadtree_depth);
Cvar_RegisterVariable(&physics_ode_contactsurfacelayer);
- Cvar_RegisterVariable(&physics_ode_worldstep);
Cvar_RegisterVariable(&physics_ode_worldstep_iterations);
Cvar_RegisterVariable(&physics_ode_contact_mu);
Cvar_RegisterVariable(&physics_ode_contact_erp);
#ifdef USEODE
static void World_Physics_Frame_BodyToEntity(world_t *world, prvm_edict_t *ed)
{
+ prvm_prog_t *prog = world->prog;
const dReal *avel;
const dReal *o;
const dReal *r; // for some reason dBodyGetRotation returns a [3][4] matrix
{
float pitchsign = 1;
- if(!strcmp(prog->name, "server")) // FIXME some better way?
+ if(prog == SVVM_prog) // FIXME some better way?
{
- pitchsign = SV_GetPitchSign(ed);
+ pitchsign = SV_GetPitchSign(prog, ed);
}
- else if(!strcmp(prog->name, "client"))
+ else if(prog == CLVM_prog)
{
- pitchsign = CL_GetPitchSign(ed);
+ pitchsign = CL_GetPitchSign(prog, ed);
}
angles[PITCH] *= pitchsign;
avelocity[PITCH] *= pitchsign;
VectorCopy(avelocity, ed->priv.server->ode_avelocity);
ed->priv.server->ode_gravity = dBodyGetGravityMode(body) != 0;
- if(!strcmp(prog->name, "server")) // FIXME some better way?
+ if(prog == SVVM_prog) // FIXME some better way?
{
SV_LinkEdict(ed);
SV_LinkEdict_TouchAreaGrid(ed);
static void World_Physics_Frame_JointFromEntity(world_t *world, prvm_edict_t *ed)
{
+ prvm_prog_t *prog = world->prog;
dJointID j = 0;
dBodyID b1 = 0;
dBodyID b2 = 0;
static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
{
+ prvm_prog_t *prog = world->prog;
const float *iv;
const int *ie;
dBodyID body = (dBodyID)ed->priv.server->ode_body;
movetype = (int)PRVM_gameedictfloat(ed, movetype);
scale = PRVM_gameedictfloat(ed, scale);if (!scale) scale = 1.0f;
modelindex = 0;
- if (world == &sv.world)
- mempool = sv_mempool;
- else if (world == &cl.world)
- mempool = cls.levelmempool;
- else
- mempool = NULL;
+ mempool = prog->progs_mempool;
model = NULL;
switch(solid)
{
if (massval * geomsize[0] * geomsize[1] * geomsize[2] == 0)
{
if (movetype == MOVETYPE_PHYSICS)
- Con_Printf("entity %i (classname %s) .mass * .size_x * .size_y * .size_z == 0\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));
+ Con_Printf("entity %i (classname %s) .mass * .size_x * .size_y * .size_z == 0\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(prog, PRVM_gameedictstring(ed, classname)));
massval = 1.0f;
VectorSet(geomsize, 1.0f, 1.0f, 1.0f);
}
ed->priv.server->ode_offsetmatrix = identitymatrix;
if (!model)
{
- Con_Printf("entity %i (classname %s) has no model\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));
+ Con_Printf("entity %i (classname %s) has no model\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(prog, PRVM_gameedictstring(ed, classname)));
goto treatasbox;
}
// add an optimized mesh to the model containing only the SUPERCONTENTS_SOLID surfaces
Mod_CreateCollisionMesh(model);
if (!model->brush.collisionmesh || !model->brush.collisionmesh->numtriangles)
{
- Con_Printf("entity %i (classname %s) has no geometry\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));
+ Con_Printf("entity %i (classname %s) has no geometry\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(prog, PRVM_gameedictstring(ed, classname)));
goto treatasbox;
}
// ODE requires persistent mesh storage, so we need to copy out
VectorCopy(angles, qangles);
VectorCopy(avelocity, qavelocity);
- if(!strcmp(prog->name, "server")) // FIXME some better way?
+ if(prog == SVVM_prog) // FIXME some better way?
{
- pitchsign = SV_GetPitchSign(ed);
+ pitchsign = SV_GetPitchSign(prog, ed);
}
- else if(!strcmp(prog->name, "client"))
+ else if(prog == CLVM_prog)
{
- pitchsign = CL_GetPitchSign(ed);
+ pitchsign = CL_GetPitchSign(prog, ed);
}
qangles[PITCH] *= pitchsign;
qavelocity[PITCH] *= pitchsign;
modified = true;
//Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .axis_forward = '%f %f %f' .axis_left = '%f %f %f' .axis_up = %f %f %f' .spinvelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], forward[0], forward[1], forward[2], left[0], left[1], left[2], up[0], up[1], up[2], spinvelocity[0], spinvelocity[1], spinvelocity[2]);
if (physics_ode_trick_fixnan.integer >= 2)
- Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .angles = '%f %f %f' .avelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], angles[0], angles[1], angles[2], avelocity[0], avelocity[1], avelocity[2]);
+ Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .angles = '%f %f %f' .avelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(prog, PRVM_gameedictstring(ed, classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], angles[0], angles[1], angles[2], avelocity[0], avelocity[1], avelocity[2]);
test = VectorLength2(origin);
if (IS_NAN(test))
VectorClear(origin);
static void nearCallback (void *data, dGeomID o1, dGeomID o2)
{
world_t *world = (world_t *)data;
+ prvm_prog_t *prog = world->prog;
dContact contact[MAX_CONTACTS]; // max contacts per collision pair
dBodyID b1;
dBodyID b2;
bouncestop2 = 60.0f / 800.0f;
}
- if(!strcmp(prog->name, "server"))
+ if(prog == SVVM_prog)
{
if(ed1 && PRVM_serveredictfunction(ed1, touch))
{
void World_Physics_Frame(world_t *world, double frametime, double gravity)
{
+ prvm_prog_t *prog = world->prog;
double tdelta, tdelta2, tdelta3, simulationtime, collisiontime;
- tdelta = Sys_DoubleTime();
+ tdelta = Sys_DirtyTime();
#ifdef USEODE
if (world->physics.ode && physics_ode.integer)
{
prvm_edict_t *ed;
world->physics.ode_iterations = bound(1, physics_ode_iterationsperframe.integer, 1000);
- if (physics_ode_constantstep.integer)
- world->physics.ode_step = sys_ticrate.value / world->physics.ode_iterations;
+ if (physics_ode_constantstep.integer > 0 && physics_ode_constantstep.integer < 1)
+ world->physics.ode_step = physics_ode_constantstep.integer / world->physics.ode_iterations;
+ else if (physics_ode_constantstep.integer)
+ world->physics.ode_step = sys_ticrate.integer / world->physics.ode_iterations;
else
world->physics.ode_step = frametime / world->physics.ode_iterations;
world->physics.ode_movelimit = physics_ode_movelimit.value / world->physics.ode_step;
World_Physics_Frame_JointFromEntity(world, ed);
}
- tdelta2 = Sys_DoubleTime();
+ tdelta2 = Sys_DirtyTime();
collisiontime = 0;
for (i = 0;i < world->physics.ode_iterations;i++)
{
dWorldSetContactSurfaceLayer((dWorldID)world->physics.ode_world, max(0, physics_ode_contactsurfacelayer.value));
// run collisions for the current world state, creating JointGroup
- tdelta3 = Sys_DoubleTime();
+ tdelta3 = Sys_DirtyTime();
dSpaceCollide((dSpaceID)world->physics.ode_space, (void *)world, nearCallback);
- collisiontime += (Sys_DoubleTime() - tdelta3)*10000;
+ collisiontime += (Sys_DirtyTime() - tdelta3)*10000;
// run physics (move objects, calculate new velocities)
- if (physics_ode_worldstep.integer == 2)
- {
- dWorldSetQuickStepNumIterations((dWorldID)world->physics.ode_world, bound(1, physics_ode_worldstep_iterations.integer, 200));
+ // be sure not to pass 0 as step time because that causes an ODE error
+ dWorldSetQuickStepNumIterations((dWorldID)world->physics.ode_world, bound(1, physics_ode_worldstep_iterations.integer, 200));
+ if (world->physics.ode_step > 0)
dWorldQuickStep((dWorldID)world->physics.ode_world, world->physics.ode_step);
- }
-#ifdef ODE_USE_STEPFAST
- else if (physics_ode_worldstep.integer == 1)
- dWorldStepFast1((dWorldID)world->physics.ode_world, world->physics.ode_step, bound(1, physics_ode_worldstep_iterations.integer, 200));
-#endif
- else
- dWorldStep((dWorldID)world->physics.ode_world, world->physics.ode_step);
// clear the JointGroup now that we're done with it
dJointGroupEmpty((dJointGroupID)world->physics.ode_contactgroup);
}
- simulationtime = (Sys_DoubleTime() - tdelta2)*10000;
+ simulationtime = (Sys_DirtyTime() - tdelta2)*10000;
// copy physics properties from physics engine to entities and do some stats
if (prog)
if (dBodyIsEnabled(body))
world->physics.ode_activeovjects++;
}
- Con_Printf("ODE Stats(%s): %3.01f (%3.01f collision) %3.01f total : %i objects %i active %i disabled\n", prog->name, simulationtime, collisiontime, (Sys_DoubleTime() - tdelta)*10000, world->physics.ode_numobjects, world->physics.ode_activeovjects, (world->physics.ode_numobjects - world->physics.ode_activeovjects));
+ Con_Printf("ODE Stats(%s): %3.01f (%3.01f collision) %3.01f total : %i objects %i active %i disabled\n", prog->name, simulationtime, collisiontime, (Sys_DirtyTime() - tdelta)*10000, world->physics.ode_numobjects, world->physics.ode_activeovjects, (world->physics.ode_numobjects - world->physics.ode_activeovjects));
}
}
}
projects / xonotic / darkplaces.git / blobdiff