/*
    Copyright (C) 1996-1997  Id Software, Inc.
    Copyright (C) 1997       Greg Lewis

    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 the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    See file, 'COPYING', for details.
*/

#include <malloc.h>

#include "qbsp.h"


int leaffaces;
int nodefaces;
int splitnodes;
int c_solid, c_empty, c_water;

bool usemidsplit;

//============================================================================

/*
==================
FaceSide

For BSP hueristic
==================
*/
int
FaceSide(face_t *in, plane_t *split)
{
    bool frontcount, backcount;
    vec_t dot;
    int i;
    vec_t *p;

    frontcount = backcount = false;

    // axial planes are fast
    if (split->type < 3)
	for (i = 0, p = in->pts[0] + split->type; i < in->numpoints;
	     i++, p += 3) {
	    if (*p > split->dist + ON_EPSILON) {
		if (backcount)
		    return SIDE_ON;
		frontcount = true;
	    } else if (*p < split->dist - ON_EPSILON) {
		if (frontcount)
		    return SIDE_ON;
		backcount = true;
	    }
    } else
	// sloping planes take longer
	for (i = 0, p = in->pts[0]; i < in->numpoints; i++, p += 3) {
	    dot = DotProduct(p, split->normal);
	    dot -= split->dist;
	    if (dot > ON_EPSILON) {
		if (backcount)
		    return SIDE_ON;
		frontcount = true;
	    } else if (dot < -ON_EPSILON) {
		if (frontcount)
		    return SIDE_ON;
		backcount = true;
	    }
	}

    if (!frontcount)
	return SIDE_BACK;
    if (!backcount)
	return SIDE_FRONT;

    return SIDE_ON;
}

/*
==================
ChooseMidPlaneFromList

The clipping hull BSP doesn't worry about avoiding splits
==================
*/
surface_t *
ChooseMidPlaneFromList(surface_t *surfaces, vec3_t mins, vec3_t maxs)
{
    int j, l;
    surface_t *p, *bestsurface;
    vec_t bestvalue, value, dist;
    plane_t *plane;

    // pick the plane that splits the least
    bestvalue = 6 * 8192 * 8192;
    bestsurface = NULL;

    for (p = surfaces; p; p = p->next) {
	if (p->onnode)
	    continue;

	plane = &pPlanes[p->planenum];

	// check for axis aligned surfaces
	l = plane->type;
	if (l > PLANE_Z)
	    continue;

	// calculate the split metric along axis l, smaller values are better
	value = 0;

	dist = plane->dist * plane->normal[l];
	for (j = 0; j < 3; j++) {
	    if (j == l) {
		value += (maxs[l] - dist) * (maxs[l] - dist);
		value += (dist - mins[l]) * (dist - mins[l]);
	    } else
		value += 2 * (maxs[j] - mins[j]) * (maxs[j] - mins[j]);
	}

	if (value > bestvalue)
	    continue;

	// currently the best!
	bestvalue = value;
	bestsurface = p;
    }

    if (!bestsurface) {
	for (p = surfaces; p; p = p->next)
	    if (!p->onnode)
		return p;	// first valid surface
	Message(msgError, errNoValidPlanes);
    }

    return bestsurface;
}



/*
==================
ChoosePlaneFromList

The real BSP hueristic
==================
*/
surface_t *
ChoosePlaneFromList(surface_t *surfaces, vec3_t mins, vec3_t maxs)
{
    int j, k, l;
    surface_t *p, *p2, *bestsurface;
    int bestvalue;
    vec_t bestdistribution, value, dist;
    plane_t *plane;
    face_t *f;

    // pick the plane that splits the least
    bestvalue = 99999;
    bestsurface = NULL;
    bestdistribution = 9e30f;

    for (p = surfaces; p; p = p->next) {
	if (p->onnode)
	    continue;

	plane = &pPlanes[p->planenum];
	k = 0;

	for (p2 = surfaces; p2; p2 = p2->next) {
	    if (p2 == p || p2->onnode)
		continue;

	    for (f = p2->faces; f; f = f->next) {
		if (FaceSide(f, plane) == SIDE_ON) {
		    k++;
		    if (k >= bestvalue)
			break;
		}

	    }
	    if (k > bestvalue)
		break;
	}

	if (k > bestvalue)
	    continue;

	// if equal numbers, axial planes win, then decide on spatial subdivision

	if (k < bestvalue || (k == bestvalue && plane->type < PLANE_ANYX)) {
	    // check for axis aligned surfaces
	    l = plane->type;

	    if (l <= PLANE_Z) {	// axial aligned
		// calculate the split metric along axis l
		value = 0;

		for (j = 0; j < 3; j++) {
		    if (j == l) {
			dist = plane->dist * plane->normal[l];
			value += (maxs[l] - dist) * (maxs[l] - dist);
			value += (dist - mins[l]) * (dist - mins[l]);
		    } else
			value +=
			    2 * (maxs[j] - mins[j]) * (maxs[j] - mins[j]);
		}

		if (value > bestdistribution && k == bestvalue)
		    continue;
		bestdistribution = value;
	    }
	    // currently the best!
	    bestvalue = k;
	    bestsurface = p;
	}

    }

    return bestsurface;
}


/*
==================
SelectPartition

Selects a surface from a linked list of surfaces to split the group on
returns NULL if the surface list can not be divided any more (a leaf)
==================
*/
surface_t *
SelectPartition(surface_t *surfaces)
{
    int i, j;
    vec3_t mins, maxs;
    surface_t *p, *bestsurface;

    // count onnode surfaces
    i = 0;
    bestsurface = NULL;
    for (p = surfaces; p; p = p->next)
	if (!p->onnode) {
	    i++;
	    bestsurface = p;
	}

    if (i == 0)
	return NULL;

    if (i == 1)
	return bestsurface;	// this is a final split

    // calculate a bounding box of the entire surfaceset
    for (i = 0; i < 3; i++) {
	mins[i] = 99999;
	maxs[i] = -99999;
    }

    for (p = surfaces; p; p = p->next)
	for (j = 0; j < 3; j++) {
	    if (p->mins[j] < mins[j])
		mins[j] = p->mins[j];
	    if (p->maxs[j] > maxs[j])
		maxs[j] = p->maxs[j];
	}

    if (usemidsplit)		// do fast way for clipping hull
	return ChooseMidPlaneFromList(surfaces, mins, maxs);

    // do slow way to save poly splits for drawing hull
    return ChoosePlaneFromList(surfaces, mins, maxs);
}

//============================================================================

/*
=================
CalcSurfaceInfo

Calculates the bounding box
=================
*/
void
CalcSurfaceInfo(surface_t *surf)
{
    int i, j;
    face_t *f;

    // calculate a bounding box
    for (i = 0; i < 3; i++) {
	surf->mins[i] = 99999;
	surf->maxs[i] = -99999;
    }

    for (f = surf->faces; f; f = f->next) {
	if (f->contents[0] >= 0 || f->contents[1] >= 0)
	    Message(msgError, errBadContents);
	for (i = 0; i < f->numpoints; i++)
	    for (j = 0; j < 3; j++) {
		if (f->pts[i][j] < surf->mins[j])
		    surf->mins[j] = f->pts[i][j];
		if (f->pts[i][j] > surf->maxs[j])
		    surf->maxs[j] = f->pts[i][j];
	    }
    }
}



/*
==================
DividePlane
==================
*/
void
DividePlane(surface_t *in, plane_t *split, surface_t **front,
	    surface_t **back)
{
    face_t *facet, *next;
    face_t *frontlist, *backlist;
    face_t *frontfrag, *backfrag;
    surface_t *news;
    plane_t *inplane;

    inplane = &pPlanes[in->planenum];
    *front = *back = NULL;

    // parallel case is easy
    if (VectorCompare(inplane->normal, split->normal)) {
	// check for exactly on node
	if (inplane->dist == split->dist) {
	    facet = in->faces;
	    in->faces = NULL;
	    in->onnode = true;

	    // divide the facets to the front and back sides
	    news = (surface_t *)AllocMem(SURFACE, 1, true);
	    *news = *in;

	    // Prepend each face in facet list to either in or news lists
	    for (; facet; facet = next) {
		next = facet->next;
		if (facet->planeside == 1) {
		    facet->next = news->faces;
		    news->faces = facet;
		} else {
		    facet->next = in->faces;
		    in->faces = facet;
		}
	    }

	    if (in->faces)
		*front = in;
	    if (news->faces)
		*back = news;
	    return;
	}

	if (inplane->dist > split->dist)
	    *front = in;
	else
	    *back = in;
	return;
    }
// do a real split.  may still end up entirely on one side
// OPTIMIZE: use bounding box for fast test
    frontlist = NULL;
    backlist = NULL;

    for (facet = in->faces; facet; facet = next) {
	next = facet->next;
	SplitFace(facet, split, &frontfrag, &backfrag);
	if (frontfrag) {
	    frontfrag->next = frontlist;
	    frontlist = frontfrag;
	}
	if (backfrag) {
	    backfrag->next = backlist;
	    backlist = backfrag;
	}
    }

    // if nothing actually got split, just move the in plane
    if (frontlist == NULL) {
	*back = in;
	in->faces = backlist;
	return;
    }

    if (backlist == NULL) {
	*front = in;
	in->faces = frontlist;
	return;
    }

    // stuff got split, so allocate one new plane and reuse in
    news = (surface_t *)AllocMem(SURFACE, 1, true);
    *news = *in;
    news->faces = backlist;
    *back = news;

    in->faces = frontlist;
    *front = in;

    // recalc bboxes and flags
    CalcSurfaceInfo(news);
    CalcSurfaceInfo(in);
}

/*
==================
DivideNodeBounds
==================
*/
void
DivideNodeBounds(node_t *node, plane_t *split)
{
    VectorCopy(node->mins, node->children[0]->mins);
    VectorCopy(node->mins, node->children[1]->mins);
    VectorCopy(node->maxs, node->children[0]->maxs);
    VectorCopy(node->maxs, node->children[1]->maxs);

    // OPTIMIZE: sloping cuts can give a better bbox than this...
    if (split->type > 2)
	return;

    node->children[0]->mins[split->type] =
	node->children[1]->maxs[split->type] = split->dist;
}

/*
==================
LinkConvexFaces

Determines the contents of the leaf and creates the final list of
original faces that have some fragment inside this leaf
==================
*/
void
LinkConvexFaces(surface_t *planelist, node_t *leafnode)
{
    face_t *f, *next;
    surface_t *surf, *pnext;
    int i, count;

    leafnode->faces = NULL;
    leafnode->contents = 0;
    leafnode->planenum = -1;

    count = 0;
    for (surf = planelist; surf; surf = surf->next) {
	for (f = surf->faces; f; f = f->next) {
	    count++;
	    if (!leafnode->contents)
		leafnode->contents = f->contents[0];
	    else if (leafnode->contents != f->contents[0])
		Message(msgError, errMixedFaceContents, f->pts[0][0],
			f->pts[0][1], f->pts[0][2]);
	}
    }

    if (!leafnode->contents)
	leafnode->contents = CONTENTS_SOLID;

    switch (leafnode->contents) {
    case CONTENTS_EMPTY:
	c_empty++;
	break;
    case CONTENTS_SOLID:
	c_solid++;
	break;
    case CONTENTS_WATER:
    case CONTENTS_SLIME:
    case CONTENTS_LAVA:
    case CONTENTS_SKY:
	c_water++;
	break;
    default:
	Message(msgError, errBadContents);
    }

    // write the list of faces, and free the originals
    leaffaces += count;
    leafnode->markfaces = (face_t **)malloc(sizeof(face_t *) * (count + 1)); /* FIXME */

    i = 0;
    for (surf = planelist; surf; surf = pnext) {
	pnext = surf->next;
	for (f = surf->faces; f; f = next) {
	    next = f->next;
	    leafnode->markfaces[i] = f->original;
	    i++;
	    FreeMem(f, FACE, 1);
	}
	FreeMem(surf, SURFACE, 1);
    }
    leafnode->markfaces[i] = NULL;	// sentinal
}


/*
==================
LinkNodeFaces

Returns a duplicated list of all faces on surface
==================
*/
face_t *
LinkNodeFaces(surface_t *surface)
{
    face_t *f, *newf, **prevptr;
    face_t *list = NULL;

    // subdivide large faces
    prevptr = &surface->faces;
    f = *prevptr;
    while (f) {
	SubdivideFace(f, prevptr);
	prevptr = &(*prevptr)->next;
	f = *prevptr;
    }

    // copy
    for (f = surface->faces; f; f = f->next) {
	nodefaces++;
	newf = (face_t *)AllocMem(FACE, 1, true);
	*newf = *f;
	f->original = newf;
	newf->next = list;
	list = newf;
    }

    return list;
}


/*
==================
PartitionSurfaces
==================
*/
void
PartitionSurfaces(surface_t *surfaces, node_t *node)
{
    surface_t *split, *p, *next;
    surface_t *frontlist, *backlist;
    surface_t *frontfrag, *backfrag;
    plane_t *splitplane;

    split = SelectPartition(surfaces);
    if (!split) {		// this is a leaf node
	node->planenum = PLANENUM_LEAF;
	LinkConvexFaces(surfaces, node);
	return;
    }

    splitnodes++;
    Message(msgPercent, splitnodes, csgmergefaces);

    node->faces = LinkNodeFaces(split);
    node->children[0] = (node_t *)AllocMem(NODE, 1, true);
    node->children[1] = (node_t *)AllocMem(NODE, 1, true);
    node->planenum = split->planenum;

    splitplane = &pPlanes[split->planenum];

    DivideNodeBounds(node, splitplane);

    // multiple surfaces, so split all the polysurfaces into front and back lists
    frontlist = NULL;
    backlist = NULL;

    for (p = surfaces; p; p = next) {
	next = p->next;
	DividePlane(p, splitplane, &frontfrag, &backfrag);
	if (frontfrag && backfrag) {
	    // the plane was split, which may expose oportunities to merge
	    // adjacent faces into a single face
//                      MergePlaneFaces (frontfrag);
//                      MergePlaneFaces (backfrag);
	}

	if (frontfrag) {
	    if (!frontfrag->faces)
		Message(msgError, errNoSurfaceFaces);
	    frontfrag->next = frontlist;
	    frontlist = frontfrag;
	}
	if (backfrag) {
	    if (!backfrag->faces)
		Message(msgError, errNoSurfaceFaces);
	    backfrag->next = backlist;
	    backlist = backfrag;
	}
    }

    PartitionSurfaces(frontlist, node->children[0]);
    PartitionSurfaces(backlist, node->children[1]);
}


/*
==================
SolidBSP
==================
*/
node_t *
SolidBSP(surface_t *surfhead, bool midsplit)
{
    int i;
    node_t *headnode;

    Message(msgProgress, "SolidBSP");

    headnode = (node_t *)AllocMem(NODE, 1, true);
    usemidsplit = midsplit;

    // calculate a bounding box for the entire model
    for (i = 0; i < 3; i++) {
	headnode->mins[i] = pCurEnt->mins[i] - SIDESPACE;
	headnode->maxs[i] = pCurEnt->maxs[i] + SIDESPACE;
    }

    // recursively partition everything
    splitnodes = 0;
    leaffaces = 0;
    nodefaces = 0;
    c_solid = c_empty = c_water = 0;

    PartitionSurfaces(surfhead, headnode);

    Message(msgStat, "%5i split nodes", splitnodes);
    Message(msgStat, "%5i solid leafs", c_solid);
    Message(msgStat, "%5i empty leafs", c_empty);
    Message(msgStat, "%5i water leafs", c_water);
    Message(msgStat, "%5i leaffaces", leaffaces);
    Message(msgStat, "%5i nodefaces", nodefaces);

    return headnode;
}