svbsp.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	svbsp_node_t
struct	svbsp_t

Functions
int	SVBSP_AddPolygon (svbsp_t *b, int numpoints, const float *points, int insertoccluder, void(*fragmentcallback)(void *fragmentcallback_pointer1, int fragmentcallback_number1, svbsp_t *b, int numpoints, const float *points), void *fragmentcallback_pointer1, int fragmentcallback_number1)
void	SVBSP_Init (svbsp_t *b, const float *origin, int maxnodes, svbsp_node_t *nodes)

Function Documentation

SVBSP_AddPolygon()

int SVBSP_AddPolygon	(	svbsp_t *	b,
		int	numpoints,
		const float *	points,
		int	insertoccluder,
		void(*	fragmentcallback )(void *fragmentcallback_pointer1, int fragmentcallback_number1, svbsp_t *b, int numpoints, const float *points),
		void *	fragmentcallback_pointer1,
		int	fragmentcallback_number1 )

Definition at line 403 of file svbsp.c.

{
    int i;
    int nodenum;
    svbsp_polygon_t poly;
    // don't even consider an empty polygon
    // note we still allow points and lines to be tested...
    if (numpoints < 1)
        return 0;
    // if the polygon has too many points, we would crash
    if (numpoints > MAX_SVBSP_POLYGONPOINTS)
        return 0;
    poly.numpoints = numpoints;
    for (i = 0;i < numpoints;i++)
    {
        poly.points[i][0] = points[i*3+0];
        poly.points[i][1] = points[i*3+1];
        poly.points[i][2] = points[i*3+2];
        //poly.splitflags[i] = 0; // this edge is a valid BSP splitter - clipped edges are not (because they lie on a bsp plane)
        poly.facesplitflag = 0; // this face is a valid BSP Splitter - if it lies on a bsp plane it is not
    }
#if 0
//if (insertoccluder)
    for (i = 0;i < poly.numpoints-2;i++)
    {
        Debug_PolygonBegin(NULL, DRAWFLAG_ADDITIVE);
        Debug_PolygonVertex(poly.points[  0][0], poly.points[  0][1], poly.points[  0][2], 0.0f, 0.0f, 0.0f, 0.25f, 0.0f, 1.0f);
        Debug_PolygonVertex(poly.points[i+1][0], poly.points[i+1][1], poly.points[i+1][2], 0.0f, 0.0f, 0.0f, 0.25f, 0.0f, 1.0f);
        Debug_PolygonVertex(poly.points[i+2][0], poly.points[i+2][1], poly.points[i+2][2], 0.0f, 0.0f, 0.0f, 0.25f, 0.0f, 1.0f);
        Debug_PolygonEnd();
    }
#endif
    nodenum = 0;
    i = SVBSP_AddPolygonNode(b, &nodenum, -1, &poly, insertoccluder, fragmentcallback, fragmentcallback_pointer1, fragmentcallback_number1);
    if (insertoccluder)
    {
        if (i & 2)
            b->stat_occluders_accepted++;
        else
            b->stat_occluders_rejected++;
    }
    else
    {
        if (i & 2)
            b->stat_queries_accepted++;
        else
            b->stat_queries_rejected++;
    }
    return i;
}

References b, DRAWFLAG_ADDITIVE, svbsp_polygon_t::facesplitflag, MAX_SVBSP_POLYGONPOINTS, NULL, svbsp_polygon_t::numpoints, svbsp_polygon_t::points, and SVBSP_AddPolygonNode().

Referenced by Mod_GenerateLightmaps_CreateLights_ComputeSVBSP_InsertSurfaces(), R_Q1BSP_RecursiveGetLightInfo_BIH(), and R_Q1BSP_RecursiveGetLightInfo_BSP().

SVBSP_Init()

void SVBSP_Init	(	svbsp_t *	b,
		const float *	origin,
		int	maxnodes,
		svbsp_node_t *	nodes )

Definition at line 99 of file svbsp.c.

{
    memset(b, 0, sizeof(*b));
    b->origin[0] = origin[0];
    b->origin[1] = origin[1];
    b->origin[2] = origin[2];
    b->numnodes = 3;
    b->maxnodes = maxnodes;
    b->nodes = nodes;
    b->ranoutofnodes = 0;
    b->stat_occluders_rejected = 0;
    b->stat_occluders_accepted = 0;
    b->stat_occluders_fragments_accepted = 0;
    b->stat_occluders_fragments_rejected = 0;
    b->stat_queries_rejected = 0;
    b->stat_queries_accepted = 0;
    b->stat_queries_fragments_accepted = 0;
    b->stat_queries_fragments_rejected = 0;
 
    // the bsp tree must be initialized to have two perpendicular splits axes
    // through origin, otherwise the polygon insertions would affect the
    // opposite side of the tree, which would be disasterous.
    //
    // so this code has to make 3 nodes and 4 leafs, and since the leafs are
    // represented by empty/solid state numbers in this system rather than
    // actual structs, we only need to make the 3 nodes.
 
    // root node
    // this one splits the world into +X and -X sides
    b->nodes[0].plane[0] = 1;
    b->nodes[0].plane[1] = 0;
    b->nodes[0].plane[2] = 0;
    b->nodes[0].plane[3] = origin[0];
    b->nodes[0].parent = -1;
    b->nodes[0].children[0] = 1;
    b->nodes[0].children[1] = 2;
 
    // +X side node
    // this one splits the +X half of the world into +Y and -Y
    b->nodes[1].plane[0] = 0;
    b->nodes[1].plane[1] = 1;
    b->nodes[1].plane[2] = 0;
    b->nodes[1].plane[3] = origin[1];
    b->nodes[1].parent = 0;
    b->nodes[1].children[0] = -1;
    b->nodes[1].children[1] = -1;
 
    // -X side node
    // this one splits the -X half of the world into +Y and -Y
    b->nodes[2].plane[0] = 0;
    b->nodes[2].plane[1] = 1;
    b->nodes[2].plane[2] = 0;
    b->nodes[2].plane[3] = origin[1];
    b->nodes[2].parent = 0;
    b->nodes[2].children[0] = -1;
    b->nodes[2].children[1] = -1;
}

References b, and origin.

Referenced by Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(), and R_Q1BSP_CallRecursiveGetLightInfo().