world.c File Reference

#include "quakedef.h"
#include "clvm_cmds.h"
#include "cl_collision.h"
#include "com_list.h"

Include dependency graph for world.c:

Go to the source code of this file.

Functions
void	World_ClearLink (link_t *l)
	World_ClearLink is used for new headnodes.
void	World_End (world_t *world)
int	World_EntitiesInBox (world_t *world, const vec3_t requestmins, const vec3_t requestmaxs, int maxlist, prvm_edict_t **list)
void	World_Init (void)
void	World_InsertLinkBefore (link_t *l, link_t *before, int entitynumber)
void	World_LinkEdict (world_t *world, prvm_edict_t *ent, const vec3_t mins, const vec3_t maxs, qbool link_solid_not)
static void	World_LinkEdict_AreaGrid (world_t *world, prvm_edict_t *ent)
void	World_PrintAreaStats (world_t *world, const char *worldname)
void	World_RemoveLink (link_t *l)
void	World_SetSize (world_t *world, const char *filename, const vec3_t mins, const vec3_t maxs, prvm_prog_t *prog)
void	World_Shutdown (void)
void	World_Start (world_t *world)
void	World_UnlinkAll (world_t *world)
	unlinks all entities (used before reallocation of edicts)
void	World_UnlinkEdict (prvm_edict_t *ent)

Function Documentation

World_ClearLink()

void World_ClearLink

(

link_t *

l

)

World_ClearLink is used for new headnodes.

Definition at line 79 of file world.c.

{
    l->entitynumber = 0;
    l->list.prev = l->list.next = &l->list;
}

References link_t::entitynumber, link_t::list, llist_t::next, and llist_t::prev.

Referenced by World_SetSize().

World_End()

void World_End

(

world_t *

world

)

Definition at line 69 of file world.c.

{
#ifdef USEODE
    World_Physics_End(world);
#endif
}

References world.

Referenced by CLVM_reset_cmd(), and SVVM_reset_cmd().

World_EntitiesInBox()

int World_EntitiesInBox	(	world_t *	world,
		const vec3_t	requestmins,
		const vec3_t	requestmaxs,
		int	maxlist,
		prvm_edict_t **	list )

Definition at line 188 of file world.c.

{
    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];
 
    // avoid crash in showtex code on level change
    if (prog == NULL || prog->num_edicts < 1)
        return 0;
 
    // LadyHavoc: discovered this actually causes its own bugs (dm6 teleporters being too close to info_teleport_destination)
    //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);
    VectorCopy(requestmins, paddedmins);
    VectorCopy(requestmaxs, paddedmaxs);
 
    // 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((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[0] = min(AREA_GRID, igridmaxs[0]);
    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.list.next)
    {
        grid = &world->areagrid_outside;
        List_For_Each_Entry(l, &grid->list, 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->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
                {
                    if (numlist < maxlist)
                        list[numlist] = ent;
                    numlist++;
                }
                world->areagrid_stats_entitychecks++;
            }
        }
    }
    // add grid linked entities
    for (igrid[1] = igridmins[1];igrid[1] < igridmaxs[1];igrid[1]++)
    {
        grid = world->areagrid + igrid[1] * AREA_GRID + igridmins[0];
        for (igrid[0] = igridmins[0];igrid[0] < igridmaxs[0];igrid[0]++, grid++)
        {
            if (grid->list.next)
            {
                List_For_Each_Entry(l, &grid->list, 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->free && BoxesOverlap(paddedmins, paddedmaxs, ent->priv.server->areamins, ent->priv.server->areamaxs))
                        {
                            if (numlist < maxlist)
                                list[numlist] = ent;
                            numlist++;
                        }
                        //Con_Printf("%d %f %f %f %f %f %f : %d : %f %f %f %f %f %f\n", BoxesOverlap(mins, maxs, ent->priv.server->areamins, ent->priv.server->areamaxs), ent->priv.server->areamins[0], ent->priv.server->areamins[1], ent->priv.server->areamins[2], ent->priv.server->areamaxs[0], ent->priv.server->areamaxs[1], ent->priv.server->areamaxs[2], PRVM_NUM_FOR_EDICT(ent), mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
                    }
                    world->areagrid_stats_entitychecks++;
                }
            }
        }
    }
    return numlist;
}

References AREA_GRID, BoxesOverlap, link_t::entitynumber, floor(), prvm_edict_t::free, int(), link_t::list, List_For_Each_Entry, max, min, llist_t::next, NULL, prvm_prog_t::num_edicts, prvm_edict_t::priv, PRVM_EDICT_NUM, prvm_edict_t::server, VectorCopy, and world.

Referenced by CL_Cache_TraceLineSurfaces(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), SV_EntitiesInBox(), VM_CL_findbox(), and VM_CL_findradius().

World_Init()

void World_Init

(

void

)

Definition at line 38 of file world.c.

{
    Collision_Init();
#ifdef USEODE
    World_Physics_Init();
#endif
}

References Collision_Init().

Referenced by Host_Init().

World_InsertLinkBefore()

void World_InsertLinkBefore	(	link_t *	l,
		link_t *	before,
		int	entitynumber )

Definition at line 90 of file world.c.

{
    l->entitynumber = entitynumber;
    List_Add_Tail(&l->list, &before->list);
}

References link_t::entitynumber, link_t::list, and List_Add_Tail().

Referenced by World_LinkEdict_AreaGrid().

World_LinkEdict()

void World_LinkEdict	(	world_t *	world,
		prvm_edict_t *	ent,
		const vec3_t	mins,
		const vec3_t	maxs,
		qbool	link_solid_not )

Definition at line 320 of file world.c.

{
    prvm_prog_t *prog = world->prog;
    // unlink from old position first
    if (ent->priv.server->areagrid[0].list.prev)
        World_UnlinkEdict(ent);
 
    // some games don't want SOLID_NOT entities linked
    if (!link_solid_not && PRVM_serveredictfloat(ent, solid) == SOLID_NOT)
        return;
 
    // don't add the world
    if (ent == prog->edicts)
        return;
 
    // don't add free entities
    if (ent->free)
        return;
 
    VectorCopy(mins, ent->priv.server->areamins);
    VectorCopy(maxs, ent->priv.server->areamaxs);
    World_LinkEdict_AreaGrid(world, ent);
}

References prvm_prog_t::edicts, prvm_edict_t::free, maxs, mins, prvm_edict_t::priv, PRVM_serveredictfloat, prvm_edict_t::server, solid, SOLID_NOT, VectorCopy, world, World_LinkEdict_AreaGrid(), and World_UnlinkEdict().

Referenced by CL_LinkEdict(), and SV_LinkEdict().

World_LinkEdict_AreaGrid()

static void World_LinkEdict_AreaGrid ( world_t * world, prvm_edict_t * ent )

static

Definition at line 280 of file world.c.

{
    prvm_prog_t *prog = world->prog;
    link_t *grid;
    int igrid[3], igridmins[3], igridmaxs[3], gridnum, entitynumber = PRVM_NUM_FOR_EDICT(ent);
 
    if (entitynumber <= 0 || entitynumber >= prog->max_edicts || PRVM_EDICT_NUM(entitynumber) != ent)
    {
        Con_Printf ("World_LinkEdict_AreaGrid: invalid edict %p (edicts is %p, edict compared to prog->edicts is %i)\n", (void *)ent, (void *)prog->edicts, entitynumber);
        return;
    }
 
    igridmins[0] = (int) floor((ent->priv.server->areamins[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]);
    igridmins[1] = (int) floor((ent->priv.server->areamins[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]);
    //igridmins[2] = (int) floor((ent->priv.server->areamins[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]);
    igridmaxs[0] = (int) floor((ent->priv.server->areamaxs[0] + world->areagrid_bias[0]) * world->areagrid_scale[0]) + 1;
    igridmaxs[1] = (int) floor((ent->priv.server->areamaxs[1] + world->areagrid_bias[1]) * world->areagrid_scale[1]) + 1;
    //igridmaxs[2] = (int) floor((ent->priv.server->areamaxs[2] + world->areagrid_bias[2]) * world->areagrid_scale[2]) + 1;
    if (igridmins[0] < 0 || igridmaxs[0] > AREA_GRID || igridmins[1] < 0 || igridmaxs[1] > AREA_GRID || ((igridmaxs[0] - igridmins[0]) * (igridmaxs[1] - igridmins[1])) > ENTITYGRIDAREAS)
    {
        // wow, something outside the grid, store it as such
        World_InsertLinkBefore (&ent->priv.server->areagrid[0], &world->areagrid_outside, entitynumber);
        return;
    }
 
    gridnum = 0;
    for (igrid[1] = igridmins[1];igrid[1] < igridmaxs[1];igrid[1]++)
    {
        grid = world->areagrid + igrid[1] * AREA_GRID + igridmins[0];
        for (igrid[0] = igridmins[0];igrid[0] < igridmaxs[0];igrid[0]++, grid++, gridnum++)
            World_InsertLinkBefore (&ent->priv.server->areagrid[gridnum], grid, entitynumber);
    }
}

References AREA_GRID, Con_Printf(), prvm_prog_t::edicts, ENTITYGRIDAREAS, floor(), int(), prvm_prog_t::max_edicts, prvm_edict_t::priv, PRVM_EDICT_NUM, PRVM_NUM_FOR_EDICT, prvm_edict_t::server, world, and World_InsertLinkBefore().

Referenced by World_LinkEdict().

World_PrintAreaStats()

void World_PrintAreaStats	(	world_t *	world,
		const char *	worldname )

Definition at line 104 of file world.c.

{
    Con_Printf("%s areagrid check stats: %d calls %d nodes (%f per call) %d entities (%f per call)\n", worldname, world->areagrid_stats_calls, world->areagrid_stats_nodechecks, (double) world->areagrid_stats_nodechecks / (double) world->areagrid_stats_calls, world->areagrid_stats_entitychecks, (double) world->areagrid_stats_entitychecks / (double) world->areagrid_stats_calls);
    world->areagrid_stats_calls = 0;
    world->areagrid_stats_nodechecks = 0;
    world->areagrid_stats_entitychecks = 0;
}

References Con_Printf(), and world.

Referenced by CL_AreaStats_f(), and SV_AreaStats_f().

World_RemoveLink()

void World_RemoveLink

(

link_t *

l

)

Definition at line 85 of file world.c.

{
    List_Delete(&l->list);
}

References link_t::list, and List_Delete().

Referenced by World_UnlinkEdict().

World_SetSize()

void World_SetSize	(	world_t *	world,
		const char *	filename,
		const vec3_t	mins,
		const vec3_t	maxs,
		prvm_prog_t *	prog )

Definition at line 118 of file world.c.

{
    int i;
 
    dp_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)
        world->areagrid_marknumber = 1;
    // choose either the world box size, or a larger box to ensure the grid isn't too fine
    world->areagrid_size[0] = max(world->maxs[0] - world->mins[0], AREA_GRID * sv_areagrid_mingridsize.value);
    world->areagrid_size[1] = max(world->maxs[1] - world->mins[1], AREA_GRID * sv_areagrid_mingridsize.value);
    world->areagrid_size[2] = max(world->maxs[2] - world->mins[2], AREA_GRID * sv_areagrid_mingridsize.value);
    // figure out the corners of such a box, centered at the center of the world box
    world->areagrid_mins[0] = (world->mins[0] + world->maxs[0] - world->areagrid_size[0]) * 0.5f;
    world->areagrid_mins[1] = (world->mins[1] + world->maxs[1] - world->areagrid_size[1]) * 0.5f;
    world->areagrid_mins[2] = (world->mins[2] + world->maxs[2] - world->areagrid_size[2]) * 0.5f;
    world->areagrid_maxs[0] = (world->mins[0] + world->maxs[0] + world->areagrid_size[0]) * 0.5f;
    world->areagrid_maxs[1] = (world->mins[1] + world->maxs[1] + world->areagrid_size[1]) * 0.5f;
    world->areagrid_maxs[2] = (world->mins[2] + world->maxs[2] + world->areagrid_size[2]) * 0.5f;
    // now calculate the actual useful info from that
    VectorNegate(world->areagrid_mins, world->areagrid_bias);
    world->areagrid_scale[0] = AREA_GRID / world->areagrid_size[0];
    world->areagrid_scale[1] = AREA_GRID / world->areagrid_size[1];
    world->areagrid_scale[2] = AREA_GRID / world->areagrid_size[2];
    World_ClearLink(&world->areagrid_outside);
    for (i = 0;i < AREA_GRIDNODES;i++)
        World_ClearLink(&world->areagrid[i]);
    if (developer_extra.integer)
        Con_DPrintf("areagrid settings: divisions %ix%ix1 : box %f %f %f : %f %f %f size %f %f %f grid %f %f %f (mingrid %f)\n", AREA_GRID, AREA_GRID, world->areagrid_mins[0], world->areagrid_mins[1], world->areagrid_mins[2], world->areagrid_maxs[0], world->areagrid_maxs[1], world->areagrid_maxs[2], world->areagrid_size[0], world->areagrid_size[1], world->areagrid_size[2], 1.0f / world->areagrid_scale[0], 1.0f / world->areagrid_scale[1], 1.0f / world->areagrid_scale[2], sv_areagrid_mingridsize.value);
}

References AREA_GRID, AREA_GRIDNODES, Con_DPrintf(), developer_extra, dp_strlcpy, i, cvar_t::integer, max, maxs, mins, sv_areagrid_mingridsize, cvar_t::value, VectorCopy, VectorNegate, world, and World_ClearLink().

Referenced by CL_SetupWorldModel(), and SV_SpawnServer().

World_Shutdown()

void World_Shutdown

(

void

)

Definition at line 49 of file world.c.

{
#ifdef USEODE
    World_Physics_Shutdown();
#endif
}

World_Start()

void World_Start

(

world_t *

world

)

Definition at line 59 of file world.c.

{
#ifdef USEODE
    World_Physics_Start(world);
#endif
}

References world.

Referenced by CL_SetupWorldModel(), and SV_SpawnServer().

World_UnlinkAll()

void World_UnlinkAll

(

world_t *

world

)

unlinks all entities (used before reallocation of edicts)

Definition at line 159 of file world.c.

{
    prvm_prog_t *prog = world->prog;
    int i;
    link_t *grid;
    // unlink all entities one by one
    grid = &world->areagrid_outside;
    while (grid->list.next != &grid->list)
        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_Entry(grid->list.next, link_t, list)->entitynumber));
}

References AREA_GRIDNODES, i, link_t::list, List_Entry, llist_t::next, PRVM_EDICT_NUM, world, and World_UnlinkEdict().

Referenced by CLVM_begin_increase_edicts(), SV_Loadgame_f(), and SVVM_begin_increase_edicts().

World_UnlinkEdict()

void World_UnlinkEdict

(

prvm_edict_t *

ent

)

Definition at line 178 of file world.c.

{
    int i;
    for (i = 0;i < ENTITYGRIDAREAS;i++)
    {
        if (ent->priv.server->areagrid[i].list.prev)
            World_RemoveLink (&ent->priv.server->areagrid[i]);
    }
}

References ENTITYGRIDAREAS, i, prvm_edict_t::priv, prvm_edict_t::server, and World_RemoveLink().

Referenced by CLVM_free_edict(), SVVM_free_edict(), World_LinkEdict(), and World_UnlinkAll().