CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxConvert/plDistTree.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "Max.h"


#include "plDistTree.h"

plDistTree::plDistTree()
:	fRoot(-1)
{
}

plDistTree::~plDistTree()
{
}

void plDistTree::Reset()
{
	fRoot = -1;
	fNodes.Reset();
}

void plDistTree::AddBoxIData(const Box3& box, const Box3& fade, UInt32 iData)
{
	fRoot = IAddNodeRecur(fRoot, box, fade, iData);
}

BOOL plDistTree::BoxClear(const Box3& box, const Box3& fade) const
{
	return IBoxClearRecur(fRoot, box, fade);
}

BOOL plDistTree::PointClear(const Point3& pt, const Box3& fade) const
{
	return IPointClearRecur(fRoot, pt, fade);
}

BOOL plDistTree::IFadesClear(const Box3& fade0, const Box3& fade1) const
{
	// Only two ways fade can come out non-overlapping.
	// Either fade0 fades out before fade1 fades in, or v.v.

	// First case, does fade0 fade out?
	if( fade0.Max()[2] > 0 )
	{
		// does fade1 fade in?
		if( fade1.Min()[2] < 0 )
		{
			// Okay they do, does fade0 fade out before fade1 fades in?
			if( fade0.Max()[0] <= fade1.Min()[0] )
				return true;
		}
	}
	// Second case, same thing but reversed order
	if( fade1.Max()[2] > 0 )
	{
		// does fade0 fade in?
		if( fade0.Min()[2] < 0 )
		{
			// Okay they do, does fade1 fade out before fade0 fades in?
			if( fade1.Max()[0] <= fade0.Min()[0] )
				return true;
		}
	}
	return false;
}

BOOL plDistTree::IBox0ContainsBox1(const Box3& box0, const Box3& box1, const Box3& fade0, const Box3& fade1) const
{
#ifdef MAX_CONTAINS_WORKS
	if( !box0.Contains(box1) )
		return false;
#else MAX_CONTAINS_WORKS
	if( (box0.Min()[0] > box1.Min()[0])
		||(box0.Min()[1] > box1.Min()[1])
		||(box0.Min()[2] > box1.Min()[2])
		||(box0.Max()[0] < box1.Max()[0])
		||(box0.Max()[1] < box1.Max()[1])
		||(box0.Max()[2] < box1.Max()[2]) )
		return false;
#endif // MAX_CONTAINS_WORKS

	if( IFadesClear(fade0, fade1) )
		return false;

	return true;
}

BOOL plDistTree::IBoxesClear(const Box3& box0, const Box3& box1) const
{
	return (box0.Min()[0] > box1.Max()[0])
		||(box0.Max()[0] < box1.Min()[0])

		||(box0.Min()[1] > box1.Max()[1])
		||(box0.Max()[1] < box1.Min()[1])

		||(box0.Min()[2] > box1.Max()[2])
		||(box0.Max()[2] < box1.Min()[2]);
}

BOOL plDistTree::IBoxClearRecur(Int32 iNode, const Box3& box, const Box3& fade) const
{
	if( iNode < 0 )
		return true;

	if( IBoxesClear(fNodes[iNode].fBox, box) )
		return true;

	if( IFadesClear(fNodes[iNode].fFade, fade) )
		return true;

	if( fNodes[iNode].IsLeaf() )
		return false;

	int i;
	for( i = 0; i < 8; i++ )
	{
		if( !IBoxClearRecur(fNodes[iNode].fChildren[i], box, fade) )
			return false;
	}
	return true;
}

BOOL plDistTree::IPointClearRecur(Int32 iNode, const Point3& pt, const Box3& fade) const
{
	if( iNode < 0 )
		return true;

	if( !fNodes[iNode].fBox.Contains(pt) )
		return true;

	if( IFadesClear(fNodes[iNode].fFade, fade) )
		return true;

	if( fNodes[iNode].IsLeaf() )
		return false;

	int i;
	for( i = 0; i < 8; i++ )
	{
		if( !IPointClearRecur(fNodes[iNode].fChildren[i], pt, fade) )
			return false;
	}
	return true;
}


Int32 plDistTree::IAddNodeRecur(Int32 iNode, const Box3& box, const Box3& fade, UInt32 iData)
{
	// if iNode < 0, make a node for box and return that.
	if( iNode < 0 )
	{
		return INextNode(box, fade, iData);
	}

	// if the box is contained
	//		if this node is a leaf, pitch the box
	//
	//		else
	//			recur on one of 8 children, based on
	//			box's center relative to node center.

	// if the box doesn't intercect this node,
	//		replace this node with a node of combined boxes.
	//		this node becomes sibling of box.

	// if the box does intercect, but isn't contained
	//		same thing.


#if 0
	if( IBox0ContainsBox1(fNodes[iNode].fBox, box, fNodes[iNode].fFade, fade) )
	{
		if( !fNodes[iNode].IsLeaf() )
#else
	if( !fNodes[iNode].IsLeaf() && IBox0ContainsBox1(fNodes[iNode].fBox, box, fNodes[iNode].fFade, fade) )
	{
#endif
		{
			Int32 iChild = IGetChild(fNodes[iNode].fBox, box);
		
			Int32 iChildNode = IAddNodeRecur(fNodes[iNode].fChildren[iChild], box, fade, iData);
			fNodes[iNode].fChildren[iChild] = iChildNode;

			fNodes[iNode].fBox += fNodes[fNodes[iNode].fChildren[iChild]].fBox;
		}
		return iNode;
	}
	else
	{
		return IMergeNodes(iNode, box, fade, iData);
	}
}

Int32 plDistTree::IMergeNodes(Int32 iNode, const Box3& box, const Box3& fade, UInt32 iData)
{
	Box3 parBox = box;
	parBox += fNodes[iNode].fBox;

	Int32 pNode = INextNode(parBox, NonFade(), UInt32(-1));
	Int32 iChild = IGetChild(parBox, box);

	Int32 cNode = INextNode(box, fade, iData);

	fNodes[pNode].fChildren[iChild] = cNode;

	// Put the original node in the opposite quadrant from the child.
	// This handles the case where one of the bounds completely contains
	// the other. The octant structure of the tree isn't relied on, it
	// only helps balance the tree. So being wrong here won't hurt anything.
	iChild = iChild ^ 0x7;

	fNodes[pNode].fChildren[iChild] = iNode;

	fNodes[pNode].SetIsLeaf(false);

	return pNode;
}

Int32 plDistTree::IGetChild(const Box3& parent, const Box3& child) const
{
	Point3 parCenter = parent.Center();
	Point3 chiCenter = child.Center();

	Int32 idx = ((parCenter[0] < chiCenter[0]) << 0)
		| ((parCenter[1] < chiCenter[1]) << 1)
		| ((parCenter[2] < chiCenter[2]) << 2);
	return idx;
}

Int32 plDistTree::INextNode(const Box3& box, const Box3& fade, UInt32 iData)
{
	Int32 iNode = fNodes.GetCount();

	fNodes.Push();

	fNodes[iNode].fFlags = plDistNode::kIsLeaf;
	fNodes[iNode].fBox = box;
	fNodes[iNode].fFade = fade;
	fNodes[iNode].fIData = iData;
	fNodes[iNode].fChildren[0]
		= fNodes[iNode].fChildren[1]
		= fNodes[iNode].fChildren[2]
		= fNodes[iNode].fChildren[3]
		= fNodes[iNode].fChildren[4]
		= fNodes[iNode].fChildren[5]
		= fNodes[iNode].fChildren[6]
		= fNodes[iNode].fChildren[7] = -1;

	return iNode;
}

void plDistTree::HarvestBox(const Box3& box, Tab<Int32>& out) const
{
	IHarvestBoxRecur(fRoot, box, out);
}

void plDistTree::IHarvestBoxRecur(Int32 iNode, const Box3& box, Tab<Int32>& out) const
{
	if( iNode < 0 )
		return;

	if( IBoxesClear(fNodes[iNode].fBox, box) )
		return;

	if( fNodes[iNode].IsLeaf() )
	{
		out.Append(1, &iNode);
	}
	else
	{
		int i;
		for( i = 0; i < 8; i++ )
			IHarvestBoxRecur(fNodes[iNode].fChildren[i], box, out);
	}
}