source-engine/hammer/brushops.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "hammer.h"
#include "MapEntity.h"
#include "MapDefs.h"
#include "MapFace.h"
#include "hammer_mathlib.h"
#include "history.h"
#include "Error3d.h"
#include "BrushOps.h"
#include "GlobalFunctions.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


#pragma warning( disable : 4244 )  // Disable warning messages


#define	SIDE_FRONT		0
#define	SIDE_BACK		1
#define	SIDE_ON			2

#define	BOGUS_RANGE	( MAX_COORD_INTEGER * 4 )


float		lightaxis[3] = {1, 0.6f, 0.75f};

const int MAX_POINTS_ON_WINDING	= 128;


void Error(char* fmt, ...)
{
	char str[300];
	sprintf(str, fmt, (&fmt)+1);
	Msg(mwError, str);
}


/*
=============================================================================

			TURN PLANES INTO GROUPS OF FACES

=============================================================================
*/


/*
==================
NewWinding
==================
*/
winding_t *NewWinding (int points)
{
	winding_t	*w;

	if (points > MAX_POINTS_ON_WINDING)
		Error ("NewWinding: %i points", points);

	w = (winding_t *)malloc(sizeof(*w));
	w->numpoints = 0; // None are occupied yet even though allocated.
	w->p = (Vector *)calloc( points, sizeof(Vector) );

	return w;
}

void FreeWinding (winding_t *w)
{
	if (*(unsigned *)w == 0xdeaddead)
		Error ("FreeWinding: freed a freed winding");
	*(unsigned *)w = 0xdeaddead;

	if (w->p)
	{
	    free (w->p);
		w->p = NULL;
	}
	free (w);
}

size_t WindingSize(int points)
{
	return (size_t)(&((winding_t *)0)->p[points]);
}


//-----------------------------------------------------------------------------
// Purpose: Removes points that are withing a given distance from each other
//			from the winding.
// Input  : pWinding - The winding to remove duplicates from.
//			fMinDist - The minimum distance two points must be from one another
//				to be considered different. If this is zero, the points must be
//				identical to be considered duplicates.
//-----------------------------------------------------------------------------
void RemoveDuplicateWindingPoints(winding_t *pWinding, float fMinDist)
{
	for (int i = 0; i < pWinding->numpoints; i++)
	{
		for (int j = i + 1; j < pWinding->numpoints; j++)
		{
			Vector edge;
			VectorSubtract(pWinding->p[i], pWinding->p[j], edge);

			if (VectorLength(edge) < fMinDist)
			{
				if (j + 1 < pWinding->numpoints)
				{
					memmove(&pWinding->p[j], &pWinding->p[j + 1], (pWinding->numpoints - (j + 1)) * sizeof(pWinding->p[0]));
				}

				pWinding->numpoints--;
			}
		}		
	}
}


/*
==================
CopyWinding
==================
*/
winding_t	*CopyWinding (winding_t *w)
{
	int			size;
	winding_t	*c;

	c = NewWinding (w->numpoints);
	c->numpoints = w->numpoints;
	size = w->numpoints*sizeof(w->p[0]);
	memcpy (c->p, w->p, size);
	return c;
}


/*
==================
ClipWinding

Clips the winding to the plane, returning the new winding on the positive side
Frees the input winding.
==================
*/
// YWB ADDED SPLIT EPS to match qcsg splitting
#define	SPLIT_EPSILON	0.01
winding_t *ClipWinding (winding_t *in, PLANE *split)
{
	float	dists[MAX_POINTS_ON_WINDING];
	int		sides[MAX_POINTS_ON_WINDING];
	int		counts[3];
	float	dot;
	int		i, j;
	Vector	*p1, *p2, *mid;
	winding_t	*neww;
	int		maxpts;

	counts[0] = counts[1] = counts[2] = 0;

	// determine sides for each point
	for (i=0 ; i<in->numpoints ; i++)
	{
		dot = DotProduct (in->p[i], split->normal);
		dot -= split->dist;
		dists[i] = dot;
		if (dot > SPLIT_EPSILON)
			sides[i] = SIDE_FRONT;
		else if (dot < -SPLIT_EPSILON)
			sides[i] = SIDE_BACK;
		else
		{
			sides[i] = SIDE_ON;
		}
		counts[sides[i]]++;
	}
	sides[i] = sides[0];
	dists[i] = dists[0];

	if (!counts[0] && !counts[1])
		return in;

	if (!counts[0])
	{
		free (in);
		return NULL;
	}
	if (!counts[1])
		return in;

	maxpts = in->numpoints+4;	// can't use counts[0]+2 because
								// of fp grouping errors
	neww = NewWinding (maxpts);

	for (i=0 ; i<in->numpoints ; i++)
	{
		p1 = &in->p[i];

		mid = &neww->p[neww->numpoints];

		if (sides[i] == SIDE_FRONT || sides[i] == SIDE_ON)
		{
			*mid = *p1;
			neww->numpoints++;
			if (sides[i] == SIDE_ON)
				continue;
			mid = &neww->p[neww->numpoints];
		}

		if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
			continue;

	// generate a split point
		if (i == in->numpoints - 1)
			p2 = &in->p[0];
		else
			p2 = p1 + 1;

		neww->numpoints++;

		dot = dists[i] / (dists[i]-dists[i+1]);
		for (j=0 ; j<3 ; j++)
		{	// avoid round off error when possible
			if (split->normal[j] == 1)
				mid[0][j] = split->dist;
			else if (split->normal[j] == -1)
				mid[0][j] = -split->dist;
			mid[0][j] = p1[0][j] + dot*(p2[0][j]-p1[0][j]);
		}
//		mid[3] = p1[3] + dot*(p2[3]-p1[3]);
//		mid[4] = p1[4] + dot*(p2[4]-p1[4]);
	}

	if (neww->numpoints > maxpts)
		Error ("ClipWinding: points exceeded estimate");

// free the original winding
	FreeWinding (in);

	return neww;
}


//-----------------------------------------------------------------------------
// Purpose: Creates a huge quadrilateral winding given a plane.
// Input  : pPlane - Plane normal and distance to use when creating the winding.
// Output : Returns a winding with 4 points.
//-----------------------------------------------------------------------------
// dvs: read through this and clean it up
winding_t *CreateWindingFromPlane(PLANE *pPlane)
{
	int		i, x;
	float	max, v;
	Vector	org, vright, vup;
	winding_t	*w;
	
	// find the major axis
	max = -BOGUS_RANGE;
	x = -1;
	for (i=0 ; i<3; i++)
	{
		v = fabs(pPlane->normal[i]);
		if (v > max)
		{
			x = i;
			max = v;
		}
	}
	if (x==-1)
		Error ("BasePolyForPlane: no axis found");

	vup = vec3_origin;
	switch (x)
	{
		case 0:
		case 1:
			vup[2] = 1;
			break;
		case 2:
			vup[0] = 1;
			break;
	}

	v = DotProduct (vup, pPlane->normal);
	VectorMA (vup, -v, pPlane->normal, vup);
	VectorNormalize (vup);

	org = pPlane->normal * pPlane->dist;

	CrossProduct (vup, pPlane->normal, vright);

	vup = vup * MAX_TRACE_LENGTH;
	vright = vright * MAX_TRACE_LENGTH;

	// project a really big	axis aligned box onto the plane
	w = NewWinding (4);
	w->numpoints = 4;

	VectorSubtract (org, vright, w->p[0]);
	VectorAdd (w->p[0], vup, w->p[0]);

	VectorAdd (org, vright, w->p[1]);
	VectorAdd (w->p[1], vup, w->p[1]);

	VectorAdd (org, vright, w->p[2]);
	VectorSubtract (w->p[2], vup, w->p[2]);

	VectorSubtract (org, vright, w->p[3]);
	VectorSubtract (w->p[3], vup, w->p[3]);

	return w;
}


static CArray<error3d, error3d&> Errors;
static int nErrors;

void Add3dError(DWORD dwObjectID, LPCTSTR pszReason, PVOID pInfo)
{
	error3d err;
	err.dwObjectID = dwObjectID;
	err.pszReason = pszReason;
	err.pInfo = pInfo;
	Errors.Add(err);
	++nErrors;
}

int Get3dErrorCount()
{
	return nErrors;
}

error3d * Enum3dErrors(BOOL bStart)
{
	static int iCurrent = 0;

	if(bStart)
		iCurrent = 0;

	if(iCurrent == nErrors)
		return NULL;

	return & Errors.GetData()[iCurrent++];
}