===============
*/
-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 (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;
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);
cvar_t physics_ode_world_damping_linear_threshold = {0, "physics_ode_world_damping_linear_threshold", "0.01", "world linear damping threshold (see ODE User Guide); use defaults when set to -1"};
cvar_t physics_ode_world_damping_angular = {0, "physics_ode_world_damping_angular", "0.005", "world angular damping scale (see ODE User Guide); use defaults when set to -1"};
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_autodisable = {0, "physics_ode_autodisable", "1", "automatic disabling of objects which dont move for long period of time, makes object stacking a lot faster"};
//void (ODE_API *dMassSetCapsule)(dMass *, dReal density, int direction, dReal radius, dReal length);
void (ODE_API *dMassSetCapsuleTotal)(dMass *, dReal total_mass, int direction, dReal radius, dReal length);
//void (ODE_API *dMassSetCylinder)(dMass *, dReal density, int direction, dReal radius, dReal length);
-//void (ODE_API *dMassSetCylinderTotal)(dMass *, dReal total_mass, int direction, dReal radius, dReal length);
+void (ODE_API *dMassSetCylinderTotal)(dMass *, dReal total_mass, int direction, dReal radius, dReal length);
//void (ODE_API *dMassSetBox)(dMass *, dReal density, dReal lx, dReal ly, dReal lz);
void (ODE_API *dMassSetBoxTotal)(dMass *, dReal total_mass, dReal lx, dReal ly, dReal lz);
//void (ODE_API *dMassSetTrimesh)(dMass *, dReal density, dGeomID g);
//void (ODE_API *dGeomCapsuleGetParams)(dGeomID ccylinder, dReal *radius, dReal *length);
//dReal (ODE_API *dGeomCapsulePointDepth)(dGeomID ccylinder, dReal x, dReal y, dReal z);
//
-//dGeomID (ODE_API *dCreateCylinder)(dSpaceID space, dReal radius, dReal length);
+dGeomID (ODE_API *dCreateCylinder)(dSpaceID space, dReal radius, dReal length);
//void (ODE_API *dGeomCylinderSetParams)(dGeomID cylinder, dReal radius, dReal length);
//void (ODE_API *dGeomCylinderGetParams)(dGeomID cylinder, dReal *radius, dReal *length);
//
// {"dMassSetCapsule", (void **) &dMassSetCapsule},
{"dMassSetCapsuleTotal", (void **) &dMassSetCapsuleTotal},
// {"dMassSetCylinder", (void **) &dMassSetCylinder},
-// {"dMassSetCylinderTotal", (void **) &dMassSetCylinderTotal},
+ {"dMassSetCylinderTotal", (void **) &dMassSetCylinderTotal},
// {"dMassSetBox", (void **) &dMassSetBox},
{"dMassSetBoxTotal", (void **) &dMassSetBoxTotal},
// {"dMassSetTrimesh", (void **) &dMassSetTrimesh},
// {"dGeomCapsuleSetParams", (void **) &dGeomCapsuleSetParams},
// {"dGeomCapsuleGetParams", (void **) &dGeomCapsuleGetParams},
// {"dGeomCapsulePointDepth", (void **) &dGeomCapsulePointDepth},
-// {"dCreateCylinder", (void **) &dCreateCylinder},
+ {"dCreateCylinder", (void **) &dCreateCylinder},
// {"dGeomCylinderSetParams", (void **) &dGeomCylinderSetParams},
// {"dGeomCylinderGetParams", (void **) &dGeomCylinderGetParams},
// {"dCreateRay", (void **) &dCreateRay},
Cvar_RegisterVariable(&physics_ode_world_damping_linear_threshold);
Cvar_RegisterVariable(&physics_ode_world_damping_angular);
Cvar_RegisterVariable(&physics_ode_world_damping_angular_threshold);
+ Cvar_RegisterVariable(&physics_ode_world_gravitymod);
Cvar_RegisterVariable(&physics_ode_iterationsperframe);
Cvar_RegisterVariable(&physics_ode_constantstep);
Cvar_RegisterVariable(&physics_ode_movelimit);
#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)
{
case SOLID_BSP:
+ case SOLID_PHYSICS_TRIMESH:
modelindex = (int)PRVM_gameedictfloat(ed, modelindex);
if (world == &sv.world)
model = SV_GetModelByIndex(modelindex);
if (movetype != MOVETYPE_PHYSICS)
massval = 1.0f;
+ // get friction from entity
+ if (PRVM_gameedictfloat(ed, friction))
+ ed->priv.server->ode_friction = PRVM_gameedictfloat(ed, friction);
+ else
+ ed->priv.server->ode_friction = 1.0;
+
// check if we need to create or replace the geom
if (!ed->priv.server->ode_physics
|| !VectorCompare(ed->priv.server->ode_mins, entmins)
ed->priv.server->ode_mass = massval;
ed->priv.server->ode_modelindex = modelindex;
VectorMAM(0.5f, entmins, 0.5f, entmaxs, geomcenter);
+ if (PRVM_gameedictvector(ed, massofs))
+ VectorCopy(geomcenter, PRVM_gameedictvector(ed, massofs));
+ else
+ VectorMAM(0.5f, entmins, 0.5f, entmaxs, geomcenter);
ed->priv.server->ode_movelimit = min(geomsize[0], min(geomsize[1], geomsize[2]));
-
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);
}
switch(solid)
{
case SOLID_BSP:
+ case SOLID_PHYSICS_TRIMESH:
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
dMassSetSphereTotal(&mass, massval, geomsize[0] * 0.5f);
break;
case SOLID_PHYSICS_CAPSULE:
+ case SOLID_PHYSICS_CYLINDER:
axisindex = 0;
if (geomsize[axisindex] < geomsize[1])
axisindex = 1;
// because we want to support more than one axisindex, we have to
// create a transform, and turn on its cleanup setting (which will
// cause the child to be destroyed when it is destroyed)
- ed->priv.server->ode_geom = (void *)dCreateCapsule((dSpaceID)world->physics.ode_space, radius, length);
- dMassSetCapsuleTotal(&mass, massval, axisindex+1, radius, length);
+ if (solid == SOLID_PHYSICS_CAPSULE)
+ {
+ ed->priv.server->ode_geom = (void *)dCreateCapsule((dSpaceID)world->physics.ode_space, radius, length);
+ dMassSetCapsuleTotal(&mass, massval, axisindex+1, radius, length);
+ }
+ else
+ {
+ ed->priv.server->ode_geom = (void *)dCreateCylinder((dSpaceID)world->physics.ode_space, radius, length);
+ dMassSetCylinderTotal(&mass, massval, axisindex+1, radius, length);
+ }
break;
default:
Sys_Error("World_Physics_BodyFromEntity: unrecognized solid value %i was accepted by filter\n", solid);
memcpy(ed->priv.server->ode_massbuf, &mass, sizeof(dMass));
}
- if(ed->priv.server->ode_geom)
+ if (ed->priv.server->ode_geom)
dGeomSetData((dGeomID)ed->priv.server->ode_geom, (void*)ed);
if (movetype == MOVETYPE_PHYSICS && ed->priv.server->ode_geom)
{
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);
if(gravity != ed->priv.server->ode_gravity)
Con_Printf(" gravity: %i -> %i\n", ed->priv.server->ode_gravity, gravity);
#endif
-
// values for BodyFromEntity to check if the qc modified anything later
VectorCopy(origin, ed->priv.server->ode_origin);
VectorCopy(velocity, ed->priv.server->ode_velocity);
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 && ed1->fields.server->touch)
+ if(ed1 && PRVM_serveredictfunction(ed1, touch))
{
SV_LinkEdict_TouchAreaGrid_Call(ed1, ed2 ? ed2 : prog->edicts);
}
- if(ed2 && ed2->fields.server->touch)
+ if(ed2 && PRVM_serveredictfunction(ed2, touch))
{
SV_LinkEdict_TouchAreaGrid_Call(ed2, ed1 ? ed1 : prog->edicts);
}
for (i = 0;i < numcontacts;i++)
{
contact[i].surface.mode = (physics_ode_contact_mu.value != -1 ? dContactApprox1 : 0) | (physics_ode_contact_erp.value != -1 ? dContactSoftERP : 0) | (physics_ode_contact_cfm.value != -1 ? dContactSoftCFM : 0) | (bouncefactor1 > 0 ? dContactBounce : 0);
- contact[i].surface.mu = physics_ode_contact_mu.value;
+ contact[i].surface.mu = physics_ode_contact_mu.value * ed1->priv.server->ode_friction * ed2->priv.server->ode_friction;
contact[i].surface.soft_erp = physics_ode_contact_erp.value;
contact[i].surface.soft_cfm = physics_ode_contact_cfm.value;
contact[i].surface.bounce = bouncefactor1;
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)
{
World_Physics_Frame_JointFromEntity(world, ed);
}
- tdelta2 = Sys_DoubleTime();
+ tdelta2 = Sys_DirtyTime();
collisiontime = 0;
for (i = 0;i < world->physics.ode_iterations;i++)
{
// set the gravity
- dWorldSetGravity((dWorldID)world->physics.ode_world, 0, 0, -gravity);
+ dWorldSetGravity((dWorldID)world->physics.ode_world, 0, 0, -gravity * physics_ode_world_gravitymod.value);
// set the tolerance for closeness of objects
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)
// 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