CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plGeoSpanDice.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 <memory.h>

#include "hsTypes.h"
#include "plGeoSpanDice.h"
#include "plGeometrySpan.h"

plGeoSpanDice::plGeoSpanDice()
:	fMinFaces(0),
	fMaxFaces(0)
{
	fMaxSize.Set(0,0,0);
}

plGeoSpanDice::~plGeoSpanDice()
{
}

hsBool plGeoSpanDice::Dice(hsTArray<plGeometrySpan*>& spans) const
{
	int startingCount = spans.GetCount();

	hsTArray<plGeometrySpan*> out;
	hsTArray<plGeometrySpan*> next;

	while(spans.GetCount())
	{
		int i;
		for( i = 0; i < spans.GetCount(); i++ )
		{
			if( !IHalf(spans[i], next) )
			{
				out.Append(spans[i]);
			}
		}
		spans.Swap(next);
		next.SetCount(0);
	}
	spans.Swap(out);

	return spans.GetCount() != startingCount;
}

hsBool plGeoSpanDice::INeedSplitting(plGeometrySpan* src) const
{
	// Do we have enough faces to bother?
	if( fMinFaces )
	{
		if( src->fNumIndices < fMinFaces * 3 )
			return false;
	}
	// Do we have enough faces to bother no matter how small we are?
	if( fMaxFaces )
	{
		if( src->fNumIndices > fMaxFaces * 3 )
			return true;
	}
	// Are we big enough to bother?
	if( (fMaxSize.fX > 0) || (fMaxSize.fY > 0) || (fMaxSize.fZ > 0) )
	{
		hsPoint3 size = src->fLocalBounds.GetMaxs() - src->fLocalBounds.GetMins();
		if( size.fX > fMaxSize.fX )
			return true;
		if( size.fY > fMaxSize.fY )
			return true;
		if( size.fZ > fMaxSize.fZ )
			return true;
	}

	return false;
}

hsBool plGeoSpanDice::IHalf(plGeometrySpan* src, hsTArray<plGeometrySpan*>& out, int exclAxis) const
{
	if( !INeedSplitting(src) )
		return false;

	int iAxis = ISelectAxis(exclAxis, src);
	// Ran out of axes to try.
	if( iAxis < 0 )
		return false;

	hsScalar midPoint = src->fLocalBounds.GetCenter()[iAxis];

	hsTArray<UInt32>		loTris;
	hsTArray<UInt32>		hiTris;

	UInt16* indexData = src->fIndexData;

	int numTris = src->fNumIndices / 3;

	int stride = src->GetVertexSize(src->fFormat);

	int i;
	for( i = 0; i < numTris; i++ )
	{
		hsPoint3& pos0 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride);
		hsPoint3& pos1 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride);
		hsPoint3& pos2 = *(hsPoint3*)(src->fVertexData + *indexData++ * stride);

		if( (pos0[iAxis] >= midPoint)
			&&(pos1[iAxis] >= midPoint)
			&&(pos2[iAxis] >= midPoint) )
		{
			hiTris.Append(i);
		}
		else
		{
			loTris.Append(i);
		}
	}

	// This axis isn't working out, try another.
	if( !hiTris.GetCount() || !loTris.GetCount() )
		return IHalf(src, out, exclAxis | (1 << iAxis));


	plGeometrySpan* loDst = IExtractTris(src, loTris);
	plGeometrySpan* hiDst = IExtractTris(src, hiTris);

	delete src;

	out.Append(loDst);
	out.Append(hiDst);

	return true;
}

int plGeoSpanDice::ISelectAxis(int exclAxis, plGeometrySpan* src) const
{
	int iAxis = -1;
	hsScalar maxDim = 0;

	int i;
	for( i = 0; i < 3; i++ )
	{
		// Check to see if we've already tried this one.
		if( exclAxis & (1 << i) )
			continue;

		hsScalar dim = src->fLocalBounds.GetMaxs()[i] - src->fLocalBounds.GetMins()[i];
		if( dim > maxDim )
		{
			maxDim = dim;
			iAxis = i;
		}
	}
	return iAxis;
}

plGeometrySpan* plGeoSpanDice::IExtractTris(plGeometrySpan* src, hsTArray<UInt32>& tris) const
{
	// First off, find out how many and which vers we're talking here.
	// Easiest way is while we're building the LUTs we'll want later anyway.
	hsTArray<Int16>	fwdLUT;
	fwdLUT.SetCount(src->fNumVerts);
	memset(fwdLUT.AcquireArray(), -1, src->fNumVerts * sizeof(*fwdLUT.AcquireArray()));

	hsTArray<UInt16>	bckLUT;
	bckLUT.SetCount(0);

	int i;
	for( i = 0; i < tris.GetCount(); i++ )
	{
		UInt16* idx = src->fIndexData + tris[i] * 3;
		
		if( fwdLUT[*idx] < 0 )
		{
			fwdLUT[*idx] = bckLUT.GetCount();
			bckLUT.Append(*idx);
		}

		idx++;

		if( fwdLUT[*idx] < 0 )
		{
			fwdLUT[*idx] = bckLUT.GetCount();
			bckLUT.Append(*idx);
		}

		idx++;

		if( fwdLUT[*idx] < 0 )
		{
			fwdLUT[*idx] = bckLUT.GetCount();
			bckLUT.Append(*idx);
		}
	}

	int numVerts = bckLUT.GetCount();
	int numTris = tris.GetCount();

	plGeometrySpan* dst = IAllocSpace(src, numVerts, numTris);

	// Okay, set the index data.
	UInt16* idxTrav = dst->fIndexData;
	for( i = 0; i < tris.GetCount(); i++ )
	{
		*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 0] ];
		*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 1] ];
		*idxTrav++ = fwdLUT[src->fIndexData[ tris[i] * 3 + 2] ];
	}

	// Copy over the basic vertex data
	// We'll update the bounds as we go.
	int stride = src->GetVertexSize(src->fFormat);

	hsBounds3Ext localBnd;
	localBnd.MakeEmpty();
	UInt8* vtxTrav = dst->fVertexData;
	for( i = 0; i < numVerts; i++ )
	{
		memcpy(vtxTrav, src->fVertexData + bckLUT[i] * stride, stride);		

		hsPoint3* pos = (hsPoint3*)vtxTrav;
		localBnd.Union(pos);
		vtxTrav += stride;
	}
	if( src->fProps & plGeometrySpan::kWaterHeight )
	{
		src->AdjustBounds(localBnd);
	}
	dst->fLocalBounds = localBnd;

	// Now the rest of this optional garbage.
	if( src->fMultColor )
	{
		for( i = 0; i < numVerts; i++ )
		{
			dst->fMultColor[i] = src->fMultColor[bckLUT[i]];
		}
	}
	if( src->fAddColor )
	{
		for( i = 0; i < numVerts; i++ )
		{
			dst->fAddColor[i] = src->fAddColor[bckLUT[i]];
		}
	}
	if( src->fDiffuseRGBA )
	{
		for( i = 0; i < numVerts; i++ )
		{
			dst->fDiffuseRGBA[i] = src->fDiffuseRGBA[bckLUT[i]];
		}
	}
	if( src->fSpecularRGBA )
	{
		for( i = 0; i < numVerts; i++ )
		{
			dst->fSpecularRGBA[i] = src->fSpecularRGBA[bckLUT[i]];
		}
	}
	dst->fMaxOwner = src->fMaxOwner;

	return dst;
}

plGeometrySpan* plGeoSpanDice::IAllocSpace(plGeometrySpan* src, int numVerts, int numTris) const
{
	plGeometrySpan* dst = TRACKED_NEW plGeometrySpan;
	// Do a structure copy here. That's okay, because we're going to immediately 
	// fix up the pointers and counters that shouldn't have been copied. If
	// plGeometrySpan ever gets a copy constructor, this'll blow wide open.
	*dst = *src;

	int stride = src->GetVertexSize(src->fFormat);

	dst->fNumIndices = numTris * 3;
	dst->fIndexData = TRACKED_NEW UInt16[dst->fNumIndices];

	dst->fNumVerts = numVerts;
	dst->fVertexData = TRACKED_NEW UInt8[numVerts * stride];

	if( src->fMultColor )
	{
		dst->fMultColor = TRACKED_NEW hsColorRGBA[numVerts];
	}
	if( src->fAddColor )
	{
		dst->fAddColor = TRACKED_NEW hsColorRGBA[numVerts];
	}
	if( src->fDiffuseRGBA )
	{
		dst->fDiffuseRGBA = TRACKED_NEW UInt32[numVerts];
	}
	if( src->fSpecularRGBA )
	{
		dst->fSpecularRGBA = TRACKED_NEW UInt32[numVerts];
	}

	return dst;
}