CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxConvert/plConvert.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==*/

//
// 3DSMax HeadSpin exporter
//
#include "hsTypes.h"
#include "Max.h"
#include "istdplug.h"
#include "Notify.h"
#include <commdlg.h>
#include "bmmlib.h"
#include "INode.h"

#include "plConvert.h"
#include "hsResMgr.h"
#include "hsTemplates.h"

#include "hsConverterUtils.h"
#include "hsControlConverter.h"
#include "plMeshConverter.h"
#include "hsMaterialConverter.h"
#include "plLayerConverter.h"
#include "UserPropMgr.h"
#include "hsStringTokenizer.h"
#include "../MaxExport/plErrorMsg.h"
#include "hsVertexShader.h"
#include "plLightMapGen.h"
#include "plBitmapCreator.h"
#include "plgDispatch.h"

#include "../pnMessage/plTimeMsg.h"
#include "../MaxComponent/plComponent.h"
#include "../MaxMain/plMaxNode.h"
#include "../plMessage/plNodeCleanupMsg.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../MaxComponent/plClusterComponent.h"

#include "../plPhysX/plSimulationMgr.h"
#include "../MaxMain/plPhysXCooking.h"
#include "../MaxExport/plExportProgressBar.h"
#include "hsUtils.h"

#include "../MaxMain/plGetLocationDlg.h"

#ifdef HS_DEBUGGING
#define HS_NO_TRY
#endif

plConvert::plConvert() : fWarned(0)
{
}

plConvert& plConvert::Instance()
{
	static plConvert theInstance;
	return theInstance;
}

hsBool plConvert::IOK()
{
	return (!fQuit && !fpErrorMsg->IsBogus() ) ? true: false;
}

hsBool plConvert::Convert()
{
#ifndef HS_NO_TRY
	try
#endif
	{
	fSettings->fReconvert = false;
	fWarned = 0;

	fInterface->SetIncludeXRefsInHierarchy(TRUE);

	plMaxNode *pNode = (plMaxNode *)fInterface->GetRootNode();
	AddMessageToQueue(new plTransformMsg(nil, nil, nil, nil));
	AddMessageToQueue(new plDelayedTransformMsg(nil, nil, nil, nil));

	IFindDuplicateNames();

	plExportProgressBar bar;
	hsBool	retVal	= true;	// sometime, we might look at this

	if( !IAutoClusterRecur(pNode) )
	{
		fQuit = true;
	}

	if(IOK())
	{
		bar.Start("Clear Old Data");
		retVal = pNode->DoAllRecur( plMaxNode::ClearData,				fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Convert Validate");
		retVal = pNode->DoRecur( plMaxNode::ConvertValidate,			fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Components Initialize");
		retVal = pNode->DoRecur( plMaxNode::SetupPropertiesPass,		fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Prepare for skinning");
		retVal = pNode->DoRecur( plMaxNode::PrepareSkin,				fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Make Scene Object");
		retVal = pNode->DoRecur( plMaxNode::MakeSceneObject,			fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Make Physical");
		plPhysXCooking::Init();
		retVal = pNode->DoRecur( plMaxNode::MakePhysical,				fpErrorMsg, fSettings, &bar	);
		plPhysXCooking::Shutdown();
	}
	if(IOK())
	{
		bar.Start("Component Preconvert");
		retVal = pNode->DoRecur( plMaxNode::FirstComponentPass,			fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Make Controller");
		retVal = pNode->DoRecur( plMaxNode::MakeController,				fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{	// must be before mesh
		bar.Start("Make Coord Interface");
		retVal = pNode->DoRecur( plMaxNode::MakeCoordinateInterface,	fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{	// must be after coord interface but before pool data is created.
		bar.Start("Make Connections");
		retVal = pNode->DoRecur( plMaxNode::MakeParentOrRoomConnection,	fpErrorMsg, fSettings, &bar	);
	}

	if(IOK())
	{	// must be before simulation
		bar.Start("Make Mesh");
		retVal = pNode->DoRecur( plMaxNode::MakeMesh,					fpErrorMsg, fSettings, &bar	);
	}

	if(IOK())
	{	// doesn't matter when
		bar.Start("Make Light");
		retVal = pNode->DoRecur( plMaxNode::MakeLight,					fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{	// doesn't matter when
		bar.Start("Make Occluder");
		retVal = pNode->DoRecur( plMaxNode::MakeOccluder,				fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{	// must be after mesh
		bar.Start("Make Modifiers");
		retVal = pNode->DoRecur( plMaxNode::MakeModifiers,				fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		bar.Start("Convert Components");
		retVal = pNode->DoRecur( plMaxNode::ConvertComponents,			fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		// do this after convert
		bar.Start("Set Up Interface References");
		retVal = pNode->DoRecur( plMaxNode::MakeIfaceReferences,		fpErrorMsg, fSettings, &bar	);
	}

	if(IOK() && fSettings->fDoPreshade)
	{
		// These need to be opened after the components have had a chance to flag the MaxNodes
		plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
		hsVertexShader::Instance().Open();

		bar.Start("Preshade Geometry");
		retVal = pNode->DoRecur( plMaxNode::ShadeMesh,					fpErrorMsg, fSettings, &bar );

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

	if(IOK())
	{
		// Do this next-to-last--allows all the components to free up any temp data they kept around
		bar.Start("Component DeInit");
		retVal = pNode->DoRecur( plMaxNode::DeInitComponents,			fpErrorMsg, fSettings, &bar	);
	}
	if(IOK())
	{
		// Do this very last--it de-inits and frees all the maxNodeDatas lying around
		bar.Start("Clear MaxNodeDatas");
		retVal = pNode->DoAllRecur( plMaxNode::ClearMaxNodeData,			fpErrorMsg, fSettings, &bar	);
	}
//	fpErrorMsg->Set();

	DeInit();

	fInterface->SetIncludeXRefsInHierarchy(FALSE);

	return IOK();
	}
#ifndef HS_NO_TRY
	catch(plErrorMsg& err)
	{
		DeInit();
		fInterface->SetIncludeXRefsInHierarchy(FALSE);
		err.Show();
		return false;
	}
	catch(...)
	{
		DeInit();
		fInterface->SetIncludeXRefsInHierarchy(FALSE);
      fpErrorMsg->Set(true, "plConvert", "Unknown error during convert\n");
      fpErrorMsg->Show();
      return false;
	}
#endif
}

//#include "../MaxMain/plMaxNodeData.h"
//#include <set>

hsBool ConvertList(hsTArray<plMaxNode*>& nodes, PMaxNodeFunc p, plErrorMsg *errMsg, plConvertSettings *settings)
{
	for (int i = 0; i < nodes.Count(); i++)
	{
		(nodes[i]->*p)(errMsg, settings);
		
		if (errMsg && errMsg->IsBogus())
			return false;
	}

	return true;
}

hsBool plConvert::Convert(hsTArray<plMaxNode*>& nodes)
{
#ifndef HS_NO_TRY
	try
#endif
	{
	fSettings->fReconvert = true;

	hsBool retVal = true;

	if (IOK())
		retVal = ConvertList(nodes, plMaxNode::ClearData, fpErrorMsg, fSettings);

	if(IOK())
		retVal = ConvertList(nodes, plMaxNode::ConvertValidate,			fpErrorMsg, fSettings);
	if(IOK())
		retVal = ConvertList(nodes, plMaxNode::SetupPropertiesPass,		fpErrorMsg, fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::PrepareSkin,				fpErrorMsg, fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::MakeSceneObject,			fpErrorMsg, fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::FirstComponentPass,		fpErrorMsg, fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::MakeController,			fpErrorMsg,fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::MakeCoordinateInterface,	fpErrorMsg, fSettings);// must be before mesh
	if(IOK())
		retVal = ConvertList(nodes, plMaxNode::MakeParentOrRoomConnection,	fpErrorMsg, fSettings); // after coord, before mesh (or any other pool data).

	// These shouldn't be opened until the components have had a chance to flag the MaxNodes
	plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
	hsVertexShader::Instance().Open();

	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::MakeMesh, fpErrorMsg, fSettings);	// must be before simulation

	if(IOK())						// doesn't matter when
		retVal = ConvertList(nodes, plMaxNode::MakeLight,					fpErrorMsg, fSettings);
	if(IOK())						// doesn't matter when
		retVal = ConvertList(nodes, plMaxNode::MakeOccluder,				fpErrorMsg, fSettings);
	if(IOK())						// must be after mesh
		retVal = ConvertList(nodes, plMaxNode::MakeModifiers,				fpErrorMsg, fSettings);
	if(IOK())	
		retVal = ConvertList(nodes, plMaxNode::ConvertComponents,			fpErrorMsg, fSettings);
	if(IOK())
		retVal = ConvertList(nodes, plMaxNode::ShadeMesh,					fpErrorMsg, fSettings);

	// These may be used by components, so don't close them till the end.
	plLightMapGen::Instance().Close();
	hsVertexShader::Instance().Close();

	plgDispatch::MsgSend(new plTransformMsg(nil, nil, nil, nil));
	plgDispatch::MsgSend(new plDelayedTransformMsg(nil, nil, nil, nil));
	DeInit();

	return IOK();	
	}
#ifndef HS_NO_TRY
	catch(plErrorMsg& err)
	{
		err.Show();
		return false;
	}
	catch(...)
	{
		hsMessageBox("Unknown error during convert", "plConvert", hsMessageBoxNormal);
		return false;
	}
#endif
}

hsBool plConvert::Init(Interface *ip, plErrorMsg* msg, plConvertSettings *settings)
{
	fInterface = ip;
	fpErrorMsg = msg;
	fSettings = settings;

	// Move us to time 0, so that things like initial transforms are always consistent with the 0th frame.
	// This saves our asses from things like the patch-generation process later
	ip->SetTime( 0, false );

	hsConverterUtils::Instance().Init(true, fpErrorMsg);
	plBitmapCreator::Instance().Init(true, fpErrorMsg);
	hsMaterialConverter::Instance().Init(true, fpErrorMsg);
	hsControlConverter::Instance().Init(fpErrorMsg);
	plMeshConverter::Instance().Init(true, fpErrorMsg);
	plLayerConverter::Instance().Init(true, fpErrorMsg);

	plGetLocationDlg::Instance().ResetDefaultLocation();

	fQuit = false;

	return true;
}

void plConvert::DeInit()
{
	// Undo any autogenerated clusters.
	IAutoUnClusterRecur(fInterface->GetRootNode());

	// clear out the message queue
	for (int i = 0; i < fMsgQueue.Count(); i++)
		plgDispatch::MsgSend(fMsgQueue[i]);

	fMsgQueue.Reset();

	hsControlConverter::Instance().DeInit();
	plMeshConverter::Instance().DeInit();
	plLayerConverter::Instance().DeInit();
	// Moving this to the end of writing the files out. Yes, this means that any unused mipmaps still get
	// written to disk, including ones loaded on preload, but it's the only way to get shared texture pages
	// to work without loading in the entire age worth of reffing objects. - 5.30.2002 mcn
//	plBitmapCreator::Instance().DeInit();

	plNodeCleanupMsg *clean = TRACKED_NEW plNodeCleanupMsg();
	plgDispatch::MsgSend( clean );
}

void plConvert::AddMessageToQueue(plMessage* msg)
{
	fMsgQueue.Append(msg);
}

void plConvert::SendEnvironmentMessage(plMaxNode* pNode, plMaxNode* efxRegion, plMessage* msg, hsBool ignorePhysicals )
{
	for (int i = 0; i < pNode->NumberOfChildren(); i++)
		SendEnvironmentMessage((plMaxNode *)pNode->GetChildNode(i), efxRegion, msg, ignorePhysicals );

	// don't call ourself...
	if (pNode == efxRegion)
		return;

	// send the scene object this message:
	if (efxRegion->Contains( ((INode*)pNode)->GetNodeTM(hsConverterUtils::Instance().GetTime(pNode->GetInterface())).GetRow(3)) &&
		pNode->GetSceneObject() && ( !ignorePhysicals || !pNode->IsPhysical() ) )
		msg->AddReceiver( pNode->GetSceneObject()->GetKey() );
}

plMaxNode* plConvert::GetRootNode() 
{
	return (plMaxNode *)fInterface->GetRootNode();
}

BOOL plConvert::IAutoClusterRecur(INode* node)
{
	plMaxNode* maxNode = (plMaxNode*)node;
	plComponentBase* comp = maxNode->ConvertToComponent();

	if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
	{
		plClusterComponent* clust = (plClusterComponent*)comp;
		// Cluster decides if it needs autogen
		if( clust->AutoGen(fpErrorMsg) )
			return false;
	}
	int i;
	for( i = 0; i < node->NumberOfChildren(); i++ )
	{
		if( !IAutoClusterRecur(node->GetChildNode(i)) )
			return false;
	}
	return true;
}

BOOL plConvert::IAutoUnClusterRecur(INode* node)
{
	plMaxNode* maxNode = (plMaxNode*)node;
	plComponentBase* comp = maxNode->ConvertToComponent();

	if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
	{
		plClusterComponent* clust = (plClusterComponent*)comp;
		// Cluster remembers whether it was autogen'd.
		clust->AutoClear(fpErrorMsg);
	}
	int i;
	for( i = 0; i < node->NumberOfChildren(); i++ )
	{
		IAutoUnClusterRecur(node->GetChildNode(i));
	}
	return true;
}

bool plConvert::IFindDuplicateNames()
{
	INode *node = fInterface->GetRootNode();
	const char *name = ISearchNames(node, node);

	if (!name)
		return false;
	
	fpErrorMsg->Set(true,
		"Error in Conversion of Scene Objects",
		"Two objects in the scene share the name '%s'.\nUnique names are necessary during the export process.\n",
		name
		);
	fpErrorMsg->Show();

	return true;
}

// Recursivly search nodes for duplicate names, and return when one is found
const char *plConvert::ISearchNames(INode *node, INode *root)
{
	int count = ICountNameOccurances(root, node->GetName());
	if (count > 1)
		return node->GetName();

	for (int i = 0; i < node->NumberOfChildren(); i++)
	{
		const char *name = ISearchNames(node->GetChildNode(i), root);
		if (name)
			return name;
	}

	return nil;
}

// Recursivly search nodes for this name, and return the number of times found
int plConvert::ICountNameOccurances(INode *node, const char *name)
{
	int count = 0;

	if (!stricmp(name, node->GetName()))
		count++;

	for (int i = 0; i < node->NumberOfChildren(); i++)
		count += ICountNameOccurances(node->GetChildNode(i), name);

	return count;
}