mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-29 23:52:22 +00:00
7240d2dc80
The main goal was to get visframe out of mnode_t to make it thread-safe (each thread can have its own visframe array), but moving the plane info into mnode_t made for better data access patters when traversing the bsp tree as the plane is right there with the child indices. Nicely, the size of mnode_t is the same as before (64 bytes due to alignment), with 4 bytes wasted. Performance-wise, there seems to be very little difference. Maybe slightly slower. The unfortunate thing about the change is the plane distance is negated, possibly leading to some confusion, particularly since the box and sphere culling functions were affected. However, this is so point-plane distance calculations can be done with a single 4d dot product.
246 lines
5 KiB
C
246 lines
5 KiB
C
/*
|
|
r_efrag.c
|
|
|
|
(description)
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "QF/render.h"
|
|
#include "QF/sys.h"
|
|
|
|
#include "QF/scene/entity.h"
|
|
|
|
#include "qfalloca.h"
|
|
#include "r_internal.h"
|
|
|
|
typedef struct s_efrag_list {
|
|
struct s_efrag_list *next;
|
|
efrag_t efrags[MAX_EFRAGS];
|
|
} t_efrag_list;
|
|
|
|
static efrag_t *r_free_efrags;
|
|
static t_efrag_list *efrag_list;
|
|
|
|
entqueue_t *r_ent_queue;
|
|
|
|
/* ENTITY FRAGMENT FUNCTIONS */
|
|
|
|
static inline void
|
|
init_efrag_list (t_efrag_list *efl)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_EFRAGS - 1; i++)
|
|
efl->efrags[i].entnext = &efl->efrags[i + 1];
|
|
efl->efrags[i].entnext = 0;
|
|
}
|
|
|
|
static efrag_t *
|
|
new_efrag (void)
|
|
{
|
|
efrag_t *ef;
|
|
|
|
if (__builtin_expect (!r_free_efrags, 0)) {
|
|
t_efrag_list *efl = calloc (1, sizeof (t_efrag_list));
|
|
SYS_CHECKMEM (efl);
|
|
efl->next = efrag_list;
|
|
efrag_list = efl;
|
|
init_efrag_list (efl);
|
|
r_free_efrags = &efl->efrags[0];
|
|
}
|
|
ef = r_free_efrags;
|
|
r_free_efrags = ef->entnext;
|
|
ef->entnext = 0;
|
|
return ef;
|
|
}
|
|
|
|
void
|
|
R_ClearEfrags (void)
|
|
{
|
|
t_efrag_list *efl;
|
|
|
|
if (!efrag_list)
|
|
efrag_list = calloc (1, sizeof (t_efrag_list));
|
|
|
|
r_free_efrags = efrag_list->efrags;
|
|
for (efl = efrag_list; efl; efl = efl->next) {
|
|
init_efrag_list (efl);
|
|
if (efl->next)
|
|
efl->efrags[MAX_EFRAGS - 1].entnext = &efl->next->efrags[0];
|
|
}
|
|
}
|
|
|
|
/*
|
|
R_RemoveEfrags
|
|
|
|
Call when removing an object from the world or moving it to another position
|
|
*/
|
|
void
|
|
R_RemoveEfrags (entity_t *ent)
|
|
{
|
|
efrag_t *ef, *old, *walk, **prev;
|
|
|
|
ef = ent->visibility.efrag;
|
|
|
|
while (ef) {
|
|
prev = &ef->leaf->efrags;
|
|
while (1) {
|
|
walk = *prev;
|
|
if (!walk)
|
|
break;
|
|
if (walk == ef) { // remove this fragment
|
|
*prev = ef->leafnext;
|
|
break;
|
|
} else
|
|
prev = &walk->leafnext;
|
|
}
|
|
|
|
old = ef;
|
|
ef = ef->entnext;
|
|
|
|
// put it on the free list
|
|
old->entnext = r_free_efrags;
|
|
r_free_efrags = old;
|
|
}
|
|
|
|
ent->visibility.efrag = 0;
|
|
}
|
|
|
|
static void
|
|
R_SplitEntityOnNode (mod_brush_t *brush, entity_t *ent,
|
|
vec3_t emins, vec3_t emaxs)
|
|
{
|
|
efrag_t *ef;
|
|
plane_t *splitplane;
|
|
mleaf_t *leaf;
|
|
int sides;
|
|
efrag_t **lastlink;
|
|
int *node_stack;
|
|
int *node_ptr;
|
|
|
|
node_stack = alloca ((brush->depth + 2) * sizeof (mnode_t *));
|
|
node_ptr = node_stack;
|
|
|
|
lastlink = &ent->visibility.efrag;
|
|
|
|
*node_ptr++ = brush->numnodes;
|
|
|
|
int node_id = 0;
|
|
while (node_id != (int) brush->numnodes) {
|
|
// add an efrag if the node is a leaf
|
|
if (__builtin_expect (node_id < 0, 0)) {
|
|
if (ent->visibility.topnode_id == -1) {
|
|
ent->visibility.topnode_id = node_id;
|
|
}
|
|
|
|
leaf = brush->leafs + ~node_id;
|
|
|
|
ef = new_efrag (); // ensures ef->entnext is 0
|
|
|
|
// add the link to the chain of links on the entity
|
|
ef->entity = ent;
|
|
*lastlink = ef;
|
|
lastlink = &ef->entnext;
|
|
|
|
// add the link too the chain of links on the leaf
|
|
ef->leaf = leaf;
|
|
ef->leafnext = leaf->efrags;
|
|
leaf->efrags = ef;
|
|
|
|
node_id = *--node_ptr;
|
|
} else {
|
|
mnode_t *node = brush->nodes + node_id;
|
|
// NODE_MIXED
|
|
splitplane = (plane_t *) &node->plane;
|
|
sides = BOX_ON_PLANE_SIDE (emins, emaxs, splitplane);
|
|
|
|
if (sides == 3) {
|
|
// split on this plane
|
|
// if this is the first splitter of this bmodel, remember it
|
|
if (ent->visibility.topnode_id == -1) {
|
|
ent->visibility.topnode_id = node_id;
|
|
}
|
|
}
|
|
// recurse down the contacted sides
|
|
if (sides & 1) {
|
|
if (sides & 2)
|
|
*node_ptr++ = node->children[1];
|
|
node_id = node->children[0];
|
|
} else {
|
|
if (sides & 2)
|
|
node_id = node->children[1];
|
|
else
|
|
node_id = *--node_ptr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
R_AddEfrags (mod_brush_t *brush, entity_t *ent)
|
|
{
|
|
model_t *entmodel;
|
|
vec3_t emins, emaxs;
|
|
|
|
if (!ent->renderer.model) {
|
|
return;
|
|
}
|
|
|
|
entmodel = ent->renderer.model;
|
|
|
|
vec4f_t org = Transform_GetWorldPosition (ent->transform);
|
|
VectorAdd (org, entmodel->mins, emins);
|
|
VectorAdd (org, entmodel->maxs, emaxs);
|
|
|
|
ent->visibility.topnode_id = -1; // leaf 0 (solid space)
|
|
R_SplitEntityOnNode (brush, ent, emins, emaxs);
|
|
}
|
|
|
|
void
|
|
R_StoreEfrags (const efrag_t *efrag)
|
|
{
|
|
entity_t *ent;
|
|
model_t *model;
|
|
|
|
while (efrag) {
|
|
ent = efrag->entity;
|
|
model = ent->renderer.model;
|
|
|
|
switch (model->type) {
|
|
case mod_alias:
|
|
case mod_brush:
|
|
case mod_sprite:
|
|
case mod_iqm:
|
|
EntQueue_AddEntity (r_ent_queue, ent, model->type);
|
|
break;
|
|
default:
|
|
(void)0;//FIXME for clang
|
|
}
|
|
efrag = efrag->leafnext;
|
|
}
|
|
}
|