/*
===========
PointInLeaf
===========
*/
node_t *PointInLeaf (node_t *node, vec3_t point)
{
vec_t d;
if (node->contents)
return node;
d = DotProduct (dplanes[node->planenum].normal, point) - dplanes[node->planenum]. dist;
if (d > 0)
return PointInLeaf (node->children[0], point);
return PointInLeaf (node->children[1], point);
}
/*
===========
PlaceOccupant
===========
*/
qboolean PlaceOccupant (int num, vec3_t point, node_t *headnode)
{
node_t *n;
n = PointInLeaf (headnode, point);
if (n->contents == CONTENTS_SOLID)
return false;
n->occupied = num;
return true;
}
void PvsForOrigin (vec3_t org, byte *pvs)
{
dleaf_t *leaf;
if (!visdatasize)
{
memset (pvs, 255, (numleafs+7)/8 );
return;
}
leaf = PointInLeaf (org);
if (leaf->visofs == -1)
Error ("leaf->visofs == -1");
DecompressVis (&dvisdata[leaf->visofs], pvs);
}
//-----------------------------------------------------------------------------
// Compute the 3D skybox areas
//-----------------------------------------------------------------------------
static void Compute3DSkyboxAreas( node_t *headnode, CUtlVector<int>& areas )
{
for (int i = 0; i < g_MainMap->num_entities; ++i)
{
char* pEntity = ValueForKey(&entities[i], "classname");
if (!strcmp(pEntity, "sky_camera"))
{
// Found a 3D skybox camera, get a leaf that lies in it
node_t *pLeaf = PointInLeaf( headnode, entities[i].origin );
if (pLeaf->contents & CONTENTS_SOLID)
{
Error ("Error! Entity sky_camera in solid volume! at %.1f %.1f %.1f\n", entities[i].origin.x, entities[i].origin.y, entities[i].origin.z);
}
areas.AddToTail( pLeaf->area );
}
}
}
void dxModel::Draw(const dxVec3 &vieworigin_, const dxVec3 &viewforward_,
const dxVec3 &viewright_, const dxVec3 &viewup_)
{
if (!loaded)
{
return;
}
framecount++;
viewleaf = PointInLeaf(vieworigin_);
MarkLeaves();
renderer.SetupFrame(vieworigin_, viewforward_, viewright_, viewup_);
DrawSkyBox();
DrawWorld();
DrawEntitiesOnList();
}
/*
=================
BrushBSP
The incoming list will be freed before exiting
=================
*/
tree_t *BrushBSP (bspbrush_t *brushlist, Vector& mins, Vector& maxs)
{
node_t *node;
bspbrush_t *b;
int c_faces, c_nonvisfaces;
int c_brushes;
tree_t *tree;
int i;
vec_t volume;
qprintf ("--- BrushBSP ---\n");
tree = AllocTree ();
c_faces = 0;
c_nonvisfaces = 0;
c_brushes = 0;
for (b=brushlist ; b ; b=b->next)
{
c_brushes++;
volume = BrushVolume (b);
if (volume < microvolume)
{
Warning("Brush %i: WARNING, microbrush\n", b->original->id);
}
for (i=0 ; i<b->numsides ; i++)
{
if (b->sides[i].bevel)
continue;
if (!b->sides[i].winding)
continue;
if (b->sides[i].texinfo == TEXINFO_NODE)
continue;
if (b->sides[i].visible)
c_faces++;
else
c_nonvisfaces++;
}
AddPointToBounds (b->mins, tree->mins, tree->maxs);
AddPointToBounds (b->maxs, tree->mins, tree->maxs);
}
qprintf ("%5i brushes\n", c_brushes);
qprintf ("%5i visible faces\n", c_faces);
qprintf ("%5i nonvisible faces\n", c_nonvisfaces);
c_nodes = 0;
c_nonvis = 0;
node = AllocNode ();
node->volume = BrushFromBounds (mins, maxs);
tree->headnode = node;
node = BuildTree_r (node, brushlist);
qprintf ("%5i visible nodes\n", c_nodes/2 - c_nonvis);
qprintf ("%5i nonvis nodes\n", c_nonvis);
qprintf ("%5i leafs\n", (c_nodes+1)/2);
#if 0
{ // debug code
static node_t *tnode;
Vector p;
p[0] = -1469;
p[1] = -118;
p[2] = 119;
tnode = PointInLeaf (tree->headnode, p);
Msg("contents: %i\n", tnode->contents);
p[0] = 0;
}
#endif
return tree;
}
// HuntForWorld will never return CONTENTS_SKY or CONTENTS_SOLID leafs
dleaf_t* HuntForWorld(vec_t* point, const vec_t* plane_offset, const dplane_t* plane, int hunt_size, vec_t hunt_scale, vec_t hunt_offset)
{
dleaf_t* leaf;
int x, y, z;
int a;
vec3_t current_point;
vec3_t original_point;
vec3_t best_point;
dleaf_t* best_leaf = NULL;
vec_t best_dist = 99999999.0;
vec3_t scales;
dplane_t new_plane = *plane;
if (hunt_scale < 0.1)
{
hunt_scale = 0.1;
}
scales[0] = 0.0;
scales[1] = -hunt_scale;
scales[2] = hunt_scale;
VectorCopy(point, best_point);
VectorCopy(point, original_point);
TranslatePlane(&new_plane, plane_offset);
if (!hunt_size)
{
hunt_size = DEFAULT_HUNT_SIZE;
}
for (a = 1; a < hunt_size; a++)
{
for (x = 0; x < 3; x++)
{
current_point[0] = original_point[0] + (scales[x % 3] * a);
for (y = 0; y < 3; y++)
{
current_point[1] = original_point[1] + (scales[y % 3] * a);
for (z = 0; z < 3; z++)
{
vec3_t delta;
vec_t dist;
current_point[2] = original_point[2] + (scales[z % 3] * a);
SnapToPlane(&new_plane, current_point, hunt_offset);
VectorSubtract(current_point, original_point, delta);
dist = VectorLength(delta);
if (dist < best_dist)
{
if ((leaf = PointInLeaf(current_point)) != g_dleafs)
{
if ((leaf->contents != CONTENTS_SKY) && (leaf->contents != CONTENTS_SOLID))
{
if (x || y || z)
{
//dist = best_dist;
best_leaf = leaf;
VectorCopy(current_point, best_point);
continue;
}
else
{
VectorCopy(current_point, point);
return leaf;
}
}
}
}
}
}
}
if (best_leaf)
{
break;
}
}
VectorCopy(best_point, point);
return best_leaf;
}
