CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxConvert/plClusterUtil.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 "hsWindows.h"
#include <commdlg.h>

#include "Max.h"
#include "stdmat.h"
#include "bmmlib.h"
#include "iparamb2.h"
#include "meshdlib.h" 

#include "hsTypes.h"

#include <vector>
#include <algorithm>

#include "../MaxMain/plMaxNode.h"
#include "../MaxComponent/plComponent.h"
#include "../MaxComponent/plLightGrpComponent.h"
#include "../MaxComponent/plSoftVolumeComponent.h"

#include "plClusterUtil.h"

#include "../plDrawable/plClusterGroup.h"
#include "../plDrawable/plCluster.h"
#include "../plDrawable/plSpanTemplate.h"
#include "../plDrawable/plSpanInstance.h"
#include "../plDrawable/plGeometrySpan.h"

#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayer.h"
#include "../plScene/plVisRegion.h"
#include "../plGLight/plLightInfo.h"

#include "plMeshConverter.h"
#include "hsVertexShader.h"
#include "plLightMapGen.h"

#include "hsResMgr.h"
#include "../pnKeyedObject/plUoid.h"

#include "../pnMessage/plNodeRefMsg.h"

#include "plTweak.h"

plConst(int) kDefMinFaces(200);
plConst(int) kDefMaxFaces(1000);
plConst(hsScalar) kDefMinSize(50.f);

plClusterUtil::plClusterUtil()
:	fGroup(nil),
	fTemplNode(nil),
	fTemplate(nil),
	fMinFaces(kDefMinFaces),
	fMaxFaces(kDefMaxFaces),
	fMinSize(kDefMinSize),
	fIdx(0)
{
}

plClusterUtil::~plClusterUtil()
{
}

plClusterGroup* plClusterUtil::CreateGroup(plMaxNode* templNode, const char* name)
{
	plClusterGroup* retVal = TRACKED_NEW plClusterGroup;
	
	char buff[256];
	sprintf(buff, "%s_%s_%d", name, templNode->GetName(), fIdx++);
	hsgResMgr::ResMgr()->NewKey(buff, retVal, templNode->GetLocation(), templNode->GetLoadMask());

	plKey sceneNode = templNode->GetRoomKey();
	retVal->SetSceneNode(sceneNode);

	plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(sceneNode, plRefMsg::kOnCreate, -1, plNodeRefMsg::kGeneric);
	hsgResMgr::ResMgr()->AddViaNotify(retVal->GetKey(), refMsg, plRefFlags::kActiveRef);

	return retVal;
}

plClusterGroup* plClusterUtil::SetupGroup(plClusterGroup *group, plMaxNode* templNode, plSpanTemplateB* templ)
{
	fTemplNode = templNode;
	fGroup = group;
	fTemplate = templ;

	fGroup->fTemplate = templ;
	fGroup->ISendToSelf(plClusterGroup::kRefMaterial, templ->fMaterial);

	fGroup->fRenderLevel = templ->fRenderLevel;

	fMinInsts = fMinFaces / templ->NumTris();
	fMaxInsts = fMaxFaces / templ->NumTris();
	if( fMinInsts < 1 )
		fMinInsts = 1;
	if( fMaxInsts <= fMinInsts )
		fMaxInsts = fMinInsts+1;

	// STUB
	// Finish setting up the group here (lights, visregions, LOD), extracting all info
	// from the template node.
	ISetupGroupFromTemplate(templNode);

	return fGroup;
}

void plClusterUtil::ISetupGroupFromTemplate(plMaxNode* templ)
{
	plLightGrpComponent* liGrp = plLightGrpComponent::GetComp(templ);
	if( liGrp )
	{
		const hsTArray<plLightInfo*>& lights = liGrp->GetLightInfos();
		int i;
		for( i = 0; i < lights.GetCount(); i++ )
		{
			fGroup->ISendToSelf(plClusterGroup::kRefLight, lights[i]);
		}
	}
	if( templ->HasFade() )
	{
		hsScalar maxDist = 0;
		hsScalar minDist = 0;

		Box3 fade = templ->GetFade();
		const hsScalar kMaxMaxDist = 1.e10f;
		if( fade.Min()[2] < 0 )
		{
			minDist = fade.Min()[0];
			maxDist = kMaxMaxDist;
		}

		if( fade.Max()[2] > 0 )
			maxDist = fade.Max()[0];

		if( maxDist > minDist )
		{
			fGroup->fLOD.Set(minDist, maxDist);
		}
	}
	hsTArray<plVisRegion*> regions;
	plVisRegionComponent::CollectRegions(templ, regions);
	plEffVisSetComponent::CollectRegions(templ, regions);
	if( regions.GetCount() )
	{
		int i;
		for( i = 0; i < regions.GetCount(); i++ )
		{
			fGroup->ISendToSelf(plClusterGroup::kRefRegion, regions[i]);
		}
	}
}

class sortData
{
public:
	UInt16			fIdx0;
	UInt16			fIdx1;
	UInt16			fIdx2;
	hsScalar		fDist;

	sortData() {}
	sortData(UInt16 idx0, UInt16 idx1, UInt16 idx2, hsScalar dist)
		: fIdx0(idx0), fIdx1(idx1), fIdx2(idx2), fDist(dist)
	{
	}

	bool operator<(const sortData& ot) const { return fDist < ot.fDist; }
	bool operator>(const sortData& ot) const { return fDist > ot.fDist; }
	bool operator==(const sortData& ot) const { return fDist == ot.fDist; }
	bool operator!=(const sortData& ot) const { return fDist != ot.fDist; }
};

void plClusterUtil::ISortTemplate(plSpanTemplateB* templ) const
{
	UInt16* indexData = templ->fIndices;
	const int numTris = templ->NumTris();
	typedef std::vector<sortData> sortVec;
	sortVec vec;
	vec.resize(numTris);
	sortVec::iterator iter;
	for( iter = vec.begin(); iter != vec.end(); iter++ )
	{
		iter->fIdx0 = indexData[0];
		iter->fIdx1 = indexData[1];
		iter->fIdx2 = indexData[2];
		hsPoint3 pos;
		pos = *templ->Position(indexData[0]);
		float dist0 = pos.fX * pos.fX + pos.fY * pos.fY;
		pos = *templ->Position(indexData[1]);
		float dist1 = pos.fX * pos.fX + pos.fY * pos.fY;
		pos = *templ->Position(indexData[2]);
		float dist2 = pos.fX * pos.fX + pos.fY * pos.fY;

		iter->fDist = dist0 > dist1
			? (dist0 > dist2
				? dist0
				: dist2)
			: (dist1 > dist2
				? dist1
				: dist2);

		indexData += 3;
	}

	std::sort(vec.begin(), vec.end(), std::less<sortData>());

	indexData = templ->fIndices;
	for( iter = vec.begin(); iter != vec.end(); iter++ )
	{
		indexData[0] = iter->fIdx0;
		indexData[1] = iter->fIdx1;
		indexData[2] = iter->fIdx2;
		
		indexData += 3;
	}
}

void plClusterUtil::ITemplateFromGeo(plSpanTemplateB* templ, plGeometrySpan* geo)
{
	UInt16 format = plSpanTemplate::MakeFormat(
		true, // hasColor
		geo->GetNumUVs(), // UVW count
		geo->fFormat & plGeometrySpan::kSkinIndices, // hasWgtIdx
		(geo->fFormat & plGeometrySpan::kSkinWeightMask) >> 4, // NumWeights
		true, // hasNorm
		true // hasPos;
		);
	

	UInt32 numVerts = geo->fNumVerts;
	UInt32 numTris = geo->fNumIndices / 3;
	
	// Alloc it.
	templ->Alloc(format, numVerts, numTris);
	templ->AllocColors();

	UInt32 numPos = templ->NumPos();
	UInt32 numNorm = templ->NumNorm();
	UInt32 numUVWs = templ->NumUVWs();
	UInt32 numWeights = templ->NumWeights();
	UInt32 numColor = templ->NumColor();
	UInt32 numColor2 = templ->NumColor2();
	UInt32 numWgtIdx = templ->NumWgtIdx();

	// Fill in the data.
	memcpy(templ->fIndices, geo->fIndexData, templ->IndexSize());

	int i;
	for( i = 0; i < templ->NumVerts(); i++ )
	{
		float wgt[4];
		UInt32 wgtIdx;

		geo->ExtractInitColor(i, templ->MultColor(i), templ->AddColor(i));

		hsColorRGBA color;
		geo->ExtractVertex(i, templ->Position(i), templ->Normal(i), &color);

		if( templ->NumColor() )
			*templ->Color(i) = color.ToARGB32();
		if( templ->NumColor2() )
			*templ->Color2(i) = 0; 

		int k;
		for( k = 0; k < templ->NumUVWs(); k++ )
		{
			geo->ExtractUv(i, k, templ->UVWs(i, k));
		}
		
		if( templ->NumWeights() )
		{
			geo->ExtractWeights(i, wgt, &wgtIdx);
			int j;
			for( j = 0; j < templ->NumWeights(); j++ )
				*templ->Weight(i, j) = wgt[j];
			if( templ->NumWgtIdx() )
				*templ->WgtIdx(i) = wgtIdx;
		}
	}

	// Compute the local bounds.
	templ->ComputeBounds();

	ISortTemplate(templ);
}

plSpanTemplateB* plClusterUtil::IAddTemplate(plMaxNode* templNode, plGeometrySpan* geo)
{
	// Shade our mesh.
	// STUB

	// Create our blank template
	plSpanTemplateB* templ = TRACKED_NEW plSpanTemplateB(templNode);

	templ->fRenderLevel = templNode->GetRenderLevel(!templNode->GetNoDeferDraw());

	ITemplateFromGeo(templ, geo);

	return templ;
}

void plClusterUtil::IAddTemplates(plMaxNode* templNode, plSpanTemplTab& templs)
{
	// STUB
	// Get the Mesh

	// Figure the format and total number of verts.
	// If we're lazy or pressed for time we could use MeshConverter.
	// But we'd probably spend more time undoing MeshConverter hacks than if we start
	// from scratch.
	// But, here we go descending cheerully into hell.
	// At least with this interface we can bail and do it right later without to much
	// bloodshed.
	hsTArray<plGeometrySpan*> spanArray;
	if( !plMeshConverter::Instance().CreateSpans(templNode, spanArray, false) )
		return;

	plLightMapGen::Instance().Open(::GetCOREInterface(), ::GetCOREInterface()->GetTime(), false);
	hsVertexShader::Instance().Open();

	hsVertexShader::Instance().ShadeNode(templNode, 
				templNode->GetLocalToWorld44(), templNode->GetWorldToLocal44(), 
				spanArray);

	plLightMapGen::Instance().Close();
	hsVertexShader::Instance().Close();

	int i;
	for( i = 0; i < spanArray.GetCount(); i++ )
	{
		plSpanTemplateB* templ = IAddTemplate(templNode, spanArray[i]);
		templs.Append(1, &templ);
		templ->fMaterial = spanArray[i]->fMaterial;

		delete spanArray[i];
	}
}

Box3 plClusterUtil::IBound(const plL2WTab& src) const
{
	Box3 box;
	int i;
	for( i = 0; i < src.Count(); i++ )
	{
		box += src[i].GetTrans();
	}
	return box;
}

Point3 plClusterUtil::ILength(const plL2WTab& src) const
{
	Box3 box = IBound(src);
	return box.Max() - box.Min();
}

int plClusterUtil::ISelectAxis(const plL2WTab& src) const
{
	Box3 box = IBound(src);
	Point3 del = box.Max() - box.Min();
	if( del.x > del.y )
	{
		if( del.x > del.z )
			return 0;
		else
			return 2;
	}
	if( del.y > del.z )
		return 1;

	return 2;
}

static int sortAxis = 0;
static int cmp(const void *elem1, const void *elem2) 
{
	Matrix3* m1 = (Matrix3*) elem1;
	Matrix3* m2 = (Matrix3*) elem2;

	float d1 = m1->GetTrans()[sortAxis];
	float d2 = m2->GetTrans()[sortAxis];

	if( d1 < d2 )
		return -1;
	else if( d1 > d2 )
		return 1;

	return 0;
}


hsBool plClusterUtil::ISplitCluster(plSpanTemplateB* templ, plL2WTab& src, plL2WTab& lo, plL2WTab& hi)
{
	// Tried this, seems to work pretty well, but a more even grid is probably wiser at
	// this point.
#if 0 // MAX_SEP
	if( src.Count() <= fMinInsts)
		return false;

	// Pick an axis
	sortAxis = ISelectAxis(src);

	if( src.Count() < fMaxInsts)
	{
		Point3 len = ILength(src);
		if( len[sortAxis] < fMinSize )
			return false;
	}

	// Sort by that axis
	src.Sort(cmp);

	// Find the biggest gap
	float maxDist = 0;
	int pivot = 0;
	int i;
	for( i = 1; i < src.Count(); i++ )
	{
		float dist = src[i].GetTrans()[sortAxis] - src[i-1].GetTrans()[sortAxis];
		if( dist > maxDist )
		{
			maxDist = dist;
			pivot = i;
		}
	}
	hsAssert((pivot > 0) && (pivot < src.Count()), "Invalid pivot found");

	// Put everyone above it in hi, below it in lo
	lo.Append(pivot, src.Addr(0));
	hi.Append(src.Count()-pivot, src.Addr(pivot));

#else // MAX_SEP

	if( src.Count() <= fMinInsts )
		return false;

	// Pick an axis
	sortAxis = ISelectAxis(src);

	if( src.Count() < fMaxInsts)
	{
		Point3 len = ILength(src);
		if( len[sortAxis] < fMinSize )
			return false;
	}

	// Sort by that axis
	src.Sort(cmp);

	int pivot = src.Count() >> 1;
	lo.Append(pivot, src.Addr(0));
	hi.Append(src.Count()-pivot, src.Addr(pivot));
#endif // MAX_SEP

	return true;
}

void plClusterUtil::IFindClustersRecur(plSpanTemplateB* templ, plL2WTab& src, plL2WTabTab& dst)
{
	plL2WTab lo;
	plL2WTab hi;

	if( ISplitCluster(templ, src, lo, hi) )
	{
		// Keep going
		IFindClustersRecur(templ, lo, dst);
		IFindClustersRecur(templ, hi, dst);
	}
	else
	{
		plL2WTab* tab = TRACKED_NEW plL2WTab(src);
		dst.Append(1, &tab);
	}
}

void plClusterUtil::IFreeClustersRecur(plL2WTabTab& dst) const
{
	int i;
	for( i = 0; i < dst.Count(); i++ )
		delete dst[i];
}

inline hsScalar inlGetAlpha(UInt32* color)
{
	return hsScalar(*color >> 24) / 255.99f;
}

plSpanEncoding plClusterUtil::ISelectEncoding(plPoint3TabTab& delPosTab, plColorTabTab& colorsTab)
{
	hsBool hasColor = false;
	hsBool hasAlpha = false;
	hsScalar maxLenSq = 0;
	hsScalar maxX = 0;
	hsScalar maxY = 0;
	hsScalar maxZ = 0;
	int i;
	for( i = 0; i < delPosTab.Count(); i++ )
	{
		int j;
		if( delPosTab[i] )
		{
			plPoint3Tab& delPos = *delPosTab[i];
			for( j = 0; j < delPos.Count(); j++ )
			{
				hsScalar lenSq = delPos[j].MagnitudeSquared();
				if( lenSq > maxLenSq )
					maxLenSq = lenSq;
				hsScalar d = fabs(delPos[j].fX);
				if( d > maxX )
					maxX = d;
				d = fabs(delPos[j].fY);
				if( d > maxY )
					maxY = d;
				d = fabs(delPos[j].fZ);
				if( d > maxZ )
					maxZ = d;

			}
		}

		if( colorsTab[i] )
		{
			plColorTab& color = *colorsTab[i];
			for( j = 0; j < color.Count(); j++ )
			{
				UInt32 col = color[j];
				if( (col & 0x00ffffff) != 0x00ffffff )
					hasColor = true;
				if( (col & 0xff000000) != 0xff000000 )
					hasAlpha = true;
			}
		}
	}

	UInt32 code = 0;
	hsScalar posScale = 1.f;

	if( hasColor && hasAlpha )
		code |= plSpanEncoding::kColAI88;
	else if( hasColor )
		code |= plSpanEncoding::kColI8;
	else if( hasAlpha )
		code |= plSpanEncoding::kColA8;

	plConst(hsScalar) kPosQuantum(0.5 / 12.f); // 1/2 inch.
	hsScalar maxLen = hsSquareRoot(maxLenSq);
	if( maxLen > kPosQuantum )
	{
		if( (maxX < kPosQuantum) && (maxY < kPosQuantum) )
		{
			code |= plSpanEncoding::kPos008;
			posScale = maxLen / 255.9f;
		}
		else if( (maxLen / 255.9f) < kPosQuantum )
		{
			code |= plSpanEncoding::kPos888;
			posScale = maxLen / 255.9f;
		}
		else if( (maxLen / hsScalar(1 << 10)) < kPosQuantum )
		{
			code |= plSpanEncoding::kPos101010;
			posScale = maxLen / hsScalar(1 << 10);
		}
		else
		{
			code |= plSpanEncoding::kPos161616;
			posScale = maxLen / hsScalar(1 << 16);
		}
	}
	return plSpanEncoding(code, posScale);
}

static int CompTemplates(const void *elem1, const void *elem2) 
{
	plSpanTemplateB* templA = *((plSpanTemplateB**)elem1);
	plSpanTemplateB* templB = *((plSpanTemplateB**)elem2);

	hsScalar hA = templA->GetLocalBounds().GetMaxs().fZ;
	hsScalar hB = templB->GetLocalBounds().GetMaxs().fZ;

	if( hA < hB )
		return -1;

	if( hA > hB )
		return 1;

	return 0;
}

void plClusterUtil::ISortTemplates(plSpanTemplTab& templs) const
{
	templs.Sort(CompTemplates);

	float maxZ = -1.e33f;

	int i;
	for( i = 1; i < templs.Count(); i++ )
	{
		templs[i]->fRenderLevel.Set(templs[i-1]->fRenderLevel.Level() + 1);
	}
}

plSpanTemplTab plClusterUtil::MakeTemplates(INode* templNode)
{
	plSpanTemplTab templs;
	IAddTemplates((plMaxNode*)templNode, templs);
	ISortTemplates(templs);
	return templs;
}

void plClusterUtil::AddClusters(plL2WTab& insts, plDeformVert* def, plShadeVert* shade)
{
	plPoint3TabTab delPos;
	plColorTabTab colors;

	plL2WTabTab clusters;
	IFindClustersRecur(fTemplate, insts, clusters);

	int j;
	for( j = 0; j < clusters.Count(); j++ )
	{
		// Create a plCluster to hold them all.
		plCluster* cluster = fGroup->IAddCluster();

		// Get the delPositions and colors for all the instances
		IAllocPosAndColor(fTemplate, *clusters[j], delPos, colors);

		IDelPosAndColor(fTemplate, 
							*clusters[j],
							def, shade,
							delPos, colors);


		// Look through the results and pick out a proper encoding
		plSpanEncoding code = ISelectEncoding(delPos, colors);
		cluster->SetEncoding(code);

		// Now create, encode and add all the insts to the cluster.
		IAddInstsToCluster(cluster, fTemplate, *clusters[j], delPos, colors);

		IFreePosAndColor(delPos, colors);
	}
	
	IFreeClustersRecur(clusters);
}

void plClusterUtil::IAddInstsToCluster(plCluster* cluster, plSpanTemplateB* templ, 
									   const plL2WTab& insts, 
									   plPoint3TabTab& delPos, 
									   plColorTabTab& colors)
{
	int i;
	for( i = 0; i < insts.Count(); i++ )
	{
		plSpanInstance* span = TRACKED_NEW plSpanInstance;
		span->Alloc(cluster->GetEncoding(), templ->NumVerts());

		span->SetLocalToWorld(plMaxNodeBase::Matrix3ToMatrix44(insts[i]));

		span->Encode(cluster->GetEncoding(), templ->NumVerts(),
			delPos[i] ? delPos[i]->Addr(0) : nil,
			colors[i] ? colors[i]->Addr(0) : nil);

		cluster->IAddInst(span);
	}
}


void plClusterUtil::IAllocPosAndColor(plSpanTemplateB* templ, const plL2WTab& insts,
									plPoint3TabTab& delPos, plColorTabTab& colors)
{
	delPos.SetCount(insts.Count());
	colors.SetCount(insts.Count());

	const int numVerts = templ->NumVerts();
	int i;
	for( i = 0; i < insts.Count(); i++ )
	{
		delPos[i] = nil;
		colors[i] = nil;
	}
}

void plClusterUtil::IFreePosAndColor(plPoint3TabTab& delPos, plColorTabTab& colors) const
{
	int i;
	for( i = 0; i < delPos.Count(); i++ )
		delete delPos[i];
	for( i = 0; i < colors.Count(); i++ )
		delete colors[i];
}

void plClusterUtil::IDelPosAndColor(plSpanTemplateB* templ, 
									const plL2WTab& insts, plDeformVert* def, plShadeVert* shade,
									plPoint3TabTab& delPos, plColorTabTab& colors)
{

	hsBool doDef = def != nil;
	hsBool doCol = shade != nil;
	// For each inst
	int i;
	for( i = 0; i < insts.Count(); i++ )
	{
		hsBounds3Ext wBnd = templ->GetLocalBounds();
		hsMatrix44 l2w = plMaxNodeBase::Matrix3ToMatrix44(insts[i]);
		hsMatrix44 w2l;
		l2w.GetInverse(&w2l);
		hsMatrix44 w2lT;
		w2l.GetTranspose(&w2lT);

		wBnd.Transform(&l2w);

		if( doDef )
		{
			def->Begin(templ->GetSrcNode(), wBnd);

			delPos[i] = TRACKED_NEW plPoint3Tab;
			delPos[i]->SetCount(templ->NumVerts());
			int j;
			for( j = 0; j < templ->NumVerts(); j++ )
			{
				hsPoint3 p = l2w * *templ->Position(j);
				plPoint3Tab& dp = *delPos[i];
				dp[j] = def->GetDel(p);
				dp[j] = w2l * dp[j];
			}
			
			def->End();
		}



		// Make the stored colors the actual output UInt32.
		// templ has the mult and add colors, apply them here.
		if( doCol )
		{
			shade->Begin(templ->GetSrcNode(), wBnd);

			colors[i] = TRACKED_NEW plColorTab;
			colors[i]->SetCount(templ->NumVerts());
			int j;
			for( j = 0; j < templ->NumVerts(); j++ )
			{
				hsPoint3 pos = *templ->Position(j);
				pos += (*delPos[i])[j];
				pos = l2w * pos;

				hsVector3 norm = *templ->Normal(j);
				norm = w2lT * norm;
				
				Color rgb = shade->GetShade(pos, norm);

				rgb *= Color(templ->MultColor(j)->r, templ->MultColor(j)->g, templ->MultColor(j)->b);
				rgb += Color(templ->AddColor(j)->r, templ->AddColor(j)->g, templ->AddColor(j)->b);

				(*colors[i])[j] = hsColorRGBA().Set(rgb.r, rgb.g, rgb.b, templ->MultColor(j)->a).ToARGB32();
			}
			shade->End();
		}

	}
}